Python’da Makine Öğrenimi Modellerini API’lere Dönüştürme

Flask – Python’da Bir Web Servisleri Çatısı:

Şimdi aklınıza şu gelebilir: Web servisi nedir? Web servisi, yalnızca bir API’nin bir sunucu üzerinde barındırıldığı ve tüketilebildiği varsayımına dayanan bir API biçimidir. Web API, Web Servisi - bu terimler genellikle birbirlerinin yerine kullanılır.

Flask’e gelecek olursak, Python’da bir web servisi geliştirme çatısıdır. Python’da tek başına o yok; Django, Falcon, Hug gibi başka seçenekler de var. Ancak bu eğitimde Flask kullanacaksınız. Flask hakkında öğrenmek için bu eğitimlere başvurabilirsiniz.

Eğer Anaconda dağıtımını indirdiyseniz, Flask zaten yüklüdür. Aksi halde, şu komutla kendiniz kurmanız gerekir:

pip install flask

Flask çok minimaldir. Birçok nedenle Python geliştiricilerinin gözdesidir. Flask çatısı, minimal yapılandırma gerektiren, hafif bir yerleşik web sunucusuyla gelir ve Python kodunuzdan kontrol edilebilir. Bu da popüler olmasının nedenlerinden biridir.

Aşağıdaki kod, Flask’in sadeliğini güzel bir şekilde gösterir. Bu kod, belirli bir URL alındığında belirli bir çıktı üreten basit bir Web-API oluşturmak için kullanılır.

from flask import Flask

app = Flask(__name__)


@app.route("")
def hello():
    return "Welcome to machine learning model APIs!"


if __name__ == '__main__':
    app.run(debug=True)

Çalıştırdıktan sonra, terminalde gösterilen web adresine (adresi bir Web Tarayıcısına girerek) gidebilir ve sonucu gözlemleyebilirsiniz.

Bazı noktalar:

• Jupyter Notebook’lar markdown’lar, R ve Python ile ilgili her şey için harikadır. Ancak bir web sunucusu oluşturmaya geldiğinde tutarsız davranış gösterebilir. Bu nedenle Flask kodlarını Sublime gibi bir metin düzenleyicisinde yazmak ve kodu terminal/komut istemcisinden çalıştırmak iyi bir fikirdir.

• Dosyayı flask.py olarak adlandırmadığınızdan emin olun.

• Flask varsayılan olarak 5000 numaralı portta çalışır. Bazen Flask sunucusu bu portta sorunsuz başlar, ancak tarayıcıda veya Postman gibi herhangi bir API istemcisinde URL’yi (sunucunun terminalde döndürdüğü URL) açtığınızda çıktı alamayabilirsiniz. Aşağıdaki durumu düşünün:

• Flask’a göre, sunucusu 5000 portunda başarıyla başlamıştır, ancak tarayıcıda URL çağrıldığında hiçbir şey döndürmemiştir. Bu, port numarası çakışmasına olası bir örnek olabilir. Bu durumda, varsayılan 5000 portunu istediğiniz başka bir port numarasına değiştirmek iyi bir seçim olacaktır. Bunu aşağıdakini yaparak gerçekleştirebilirsiniz:

  app.run(debug=True,port=12345)

• Bu durumda, Flask sunucusu aşağıdakine benzer görünecektir:

Şimdi, yazdığınız kodu adım adım inceleyelim:

• Flask sınıfının bir örneğini oluşturdunuz ve Python tarafından doldurulan "name" değişkenini (__name__) geçtiniz. Bu dosya doğrudan bir Python betiği olarak çalıştırıldığında bu değişkenin değeri "main" olacaktır. Dosyayı içe aktardıysanız, "name" değeri, içe aktardığınız dosyanın adı olur. Örneğin, test.py ve run.py varsa ve test.py’yi run.py’ye içe aktardıysanız test.py’nin "name" değeri test olur (app = Flask(test)).

• hello() metodu tanımının üzerinde @app.route("") bulunur. route(), Flask’e hangi URL’nin hello() olarak tanımlanan fonksiyonu tetiklemesi gerektiğini söyleyen bir dekoratördür.

• hello() metodu, API’niz düzgün şekilde çağrıldığında (ya da tüketildiğinde) bir çıktı (Welcome to machine learning model APIs!) üretmekten sorumludur. Bu örnekte, bir web tarayıcısında localhost:5000/ adresine gitmek (Flask sunucusu 5000 portunda çalışıyorsa) istenen çıktıyı üretecektir.

Şimdi scikit-learn kullanılarak oluşturulan makine öğrenimi modellerinizi bir Flask API’sine dönüştürürken akılda tutulması gereken bazı faktörleri inceleyeceksiniz.

Flask ile Scikit-learn Modelleri

scikit-learn ile Python’da çok basitten çok karmaşığa kadar makine öğrenimi modelleri oluşturmak hiç bu kadar kolay olmamıştı. Ancak scikit-learn ile ilgili hatırlamanız gereken bazı noktalar var:

• Scikit-learn, veri madenciliği ve veri analizi için basit ve etkili araçlar sağlayan bir Python kütüphanesidir. Scikit-learn’ün başlıca modülleri şunlardır:
  • Kümeleme
  • Regresyon
  • Sınıflandırma
  • Boyut indirgeme
  • Model seçimi
  • Önişleme

(Mutlaka DataCamp’in, scikit-learn’ün çekirdek geliştiricisi Andreas Müller tarafından verilen Scikit-learn ile Denetimli Öğrenme kursuna göz atın)

• Scikit-learn, scikit-learn kullanarak eğittiğiniz modellerin serileştirilmesini ve seriden çıkarılmasını destekler. Bu, bir modeli yeniden eğitme zamanından tasarruf sağlar. Scikit-learn ile oluşturduğunuz serileştirilmiş bir kopya sayesinde bir Flask API yazabilirsiniz.
  
  
• Scikit-learn modelleri verilerin sayısal formatta olmasını gerektirir. Bu nedenle, veri kümesi sayısal olmayan kategorik özellikler içeriyorsa, bunları sayısal hale dönüştürmek önemlidir. Bu dönüşüm için scikit-learn LabelEncoder, OneHotEncoder vb. yardımcılar sağlar. Bunlar sklearn.preprocessing modülünde bulunabilir.
  
  
• Scikit-learn modelleri eksik değerleri kendiliğinden işleyemez. Veri kümenizdeki eksik değerleri kendiniz ele almanız ve ardından modelinize beslemeniz gerekir. Eksik değerleri ele almak için scikit-learn, sklearn.preprocessing modülünde bulunabilecek çok çeşitli yardımcılar sunar.

Etiket kodlama ve eksik değerler, iyi bir makine öğrenimi modeli kurmak için çok önemli olan veri önişleme adımlarıdır. Bu konuda daha fazla bilgi edinmek isterseniz DataCamp’in aşağıdaki kursuna mutlaka göz atın:

• Python’da Makine Öğrenimi için Önişleme

Bu eğitim için, birçok nedenden ötürü en popüler veri kümelerinden biri olan Titanic veri kümesini kullanacaksınız – veri kümesi iyi ve farklı türde değişkenler içerir, eksik değerler barındırır, vb. Bu DataCamp eğitimi veri kümesine dair mükemmel bir analiz içerir ve veri kümesini buradan indirebilirsiniz.

Bu veri kümesi, bir yolcunun belirli bazı bilgileri verildiğinde hayatta kalıp kalmayacağını tahmin etmeye yönelik bir sınıflandırma problemidir.

Not: Değişken ve Özellik (feature) terimleri bu eğitimde birçok yerde birbirinin yerine kullanılmıştır.

İşleri daha da basitleştirmek için yalnızca dört değişken kullanacaksınız: age, sex, embarked ve survived; burada survived sınıf etiketidir.

# Import dependencies
import pandas as pd
import numpy as np

# Load the dataset in a dataframe object and include only four features as mentioned
url = "http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
df = pd.read_csv(url)
include = ['Age', 'Sex', 'Embarked', 'Survived'] # Only four features
df_ = df[include]

"Sex" ve "Embarked" sayısal olmayan kategorik özelliklerdir ve bu nedenle sayısal dönüşüm gerektirirler. “Age” özelliğinde eksik değerler vardır. Bu değerler ortanca ya da ortalama gibi özet istatistiklerle doldurulabilir. Eksik değerler oldukça anlamlı olabilir ve gerçek dünyadaki karşılıklarının ne olduğunun araştırılmaya değer olduğu unutulmamalıdır.

Scikit-learn, içinde hiçbir şey bulunmayan hücre değerlerini NaN olarak kabul eder. Burada, NaN’leri yalnızca 0 ile değiştirecek ve bunun için bir yardımcı işlev yazacaksınız.

categoricals = []
for col, col_type in df_.dtypes.iteritems():
     if col_type == 'O':
          categoricals.append(col)
     else:
          df_[col].fillna(0, inplace=True)

Yukarıdaki kod satırları şunları yapar:

• Veri çerçevesindeki (df) tüm sütunlar üzerinde yineler ve (sayısal olmayan değerlere sahip) sütunları categorical listesine ekler.

• Eğer sütunlar sayısal olmayan değerlere sahip değilse (bu durumda yalnızca Age), eksik değeri olup olmadığını kontrol eder ve varsa 0 ile doldurur.

  NaN’leri tek bir değerle doldurmak, özellikle de NaN’leri değiştirdiğiniz miktar sayısal değişkenin gözlenen aralığı içinde kalıyorsa, istenmeyen sonuçlara yol açabilir. Sıfır, gözlenen ve meşru bir yaş değeri olmadığı için, örneğin 36 kullansaydınız ortaya çıkabilecek yanlılığı buradaki seçimle oluşturmuyorsunuz! - Kaynak

Artık eksik değerleri ele aldığınıza ve sayısal olmayan sütunları ayırdığınıza göre, bunları sayısal olanlara dönüştürmeye hazırsınız. Bunu One Hot Encoding kullanarak yapacaksınız. Pandas, verilen bir veri çerçevesi için OHE değişkenleri oluşturmak üzere basit bir get_dummies() yöntemi sağlar.

df_ohe = pd.get_dummies(df_, columns=categoricals, dummy_na=True)

OHE kullandığınızda, her sütun/değer kombinasyonu için sütun_değer formatında yeni bir sütun oluşturulur. Örneğin – “Embarked” değişkeni için OHE; “Embarked_C”, “Embarked_Q”, “Embarked_S” ve “Embarked_nan” üretecektir.

Artık veri kümenizi başarıyla önişlediniz; makine öğrenimi modelini eğitmeye hazırsınız. Bunun için bir Lojistik Regresyon sınıflandırıcısı kullanacaksınız.

from sklearn.linear_model import LogisticRegression
dependent_variable = 'Survived'
x = df_ohe[df_ohe.columns.difference([dependent_variable])]
y = df_ohe[dependent_variable]
lr = LogisticRegression()
lr.fit(x, y)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False)

Makine öğrenimi modelinizi oluşturdunuz. Şimdi bu modeli kaydedeceksiniz. Teknik olarak, bu modeli serileştireceksiniz. Python’da buna Pickle’lama denir.

Modeli Kaydetme: Serileştirme ve Seriden Çıkarma

Bunun için sklearn’ün joblib kütüphanesini kullanacaksınız.

from sklearn.externals import joblib
joblib.dump(lr, 'model.pkl')

['model.pkl']

Lojistik Regresyon modeli artık kalıcı hale getirildi. Bu modeli tek bir kod satırıyla belleğe yükleyebilirsiniz. Modeli çalışma alanınıza geri yüklemeye Seriden Çıkarma denir.

lr = joblib.load('model.pkl')

Artık kalıcı hale getirdiğiniz modeli sunmak için Flask kullanmaya hazırsınız. Flask’in başlamak için ne kadar minimalist olduğunu zaten gördünüz.

Flask kullanarak Bir Makine Öğrenimi Modelinden API Oluşturma

Modelinizi Flask ile sunmak için iki şeyi yapacaksınız:

• Uygulama başlarken, halihazırda kalıcı hale getirilmiş modeli belleğe yükleyin,
• Girdi değişkenlerini alan, bunları uygun formata dönüştüren ve tahminleri döndüren bir API uç noktası oluşturun.

Daha somut olarak, API’nize örnek girdi aşağıdaki gibi görünecektir:

[
    {"Age": 85, "Sex": "male", "Embarked": "S"},
    {"Age": 24, "Sex": '"female"', "Embarked": "C"},
    {"Age": 3, "Sex": "male", "Embarked": "C"},
    {"Age": 21, "Sex": "male", "Embarked": "S"}
]

(ki bu bir JSON list türü girdidir)

ve API’niz aşağıdakine benzer çıktı verecektir:

{"prediction": [0, 1, 1, 0]}

Tahminler, 0’ın Hayır’ı ve 1’in Evet’i temsil ettiği hayatta kalma durumlarını ifade eder.

JSON, JavaScript Object Notation’ın kısaltmasıdır ve en yaygın kullanılan veri değişim formatlarından biridir. Hızlı bir girişe ihtiyaç duyarsanız bu eğitimleri takip edin.

predict() adlı bir işlev yazalım; bu işlev şunları yapacaktır:

• Uygulama başlarken kalıcı hale getirilmiş modeli belleğe yüklemek,
• Girdi değişkenlerini alan, bunları uygun formata dönüştüren ve tahminleri döndüren bir API uç noktası oluşturmak.

Kalıcı hale getirilen bir modelin nasıl yükleneceğini zaten gördünüz. Şimdi, girdiler alındığında hayatta kalma durumunu tahmin etmek için bunu nasıl kullanabileceğinize odaklanacaksınız.

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/predict', methods=['POST'])
def predict():
     json_ = request.json
     query_df = pd.DataFrame(json_)
     query = pd.get_dummies(query_df)
     prediction = lr.predict(query)
     return jsonify({'prediction': list(prediction)})

Harika! Ancak burada küçük bir sorununuz var.

Yazdığınız işlev, yalnızca gelen isteğin, kategorik değişkenler için tüm olası değerleri içerdiği durumlarda çalışacaktır; bu ise gerçek zamanlı kullanımda her zaman geçerli olmayabilir. Gelen istek, kategorik değişkenlerin tüm olası değerlerini içermezse, predict()’in mevcut yöntem tanımına göre get_dummies(), sınıflandırıcının beklediğinden daha az sütuna sahip bir veri çerçevesi üretecek ve bu da çalışma zamanı hatasına yol açacaktır.

Bu sorunu çözmek için, model eğitiminde sütun listesini de kalıcı hale getireceksiniz. Herhangi bir Python nesnesini bir .pkl dosyasına serileştirebilirsiniz. joblib’i öncekiyle aynı şekilde kullanacaksınız.

(Daha önce tartıştığımız gibi, sunucu düzeyi kodlamanın tamamını bir metin düzenleyicisinde yapmak ve ardından terminalden çalıştırmak her zaman daha iyidir, bunu aklınızda tutun)

model_columns = list(x.columns)
joblib.dump(model_columns, 'model_columns.pkl')

['model_columns.pkl']

Artık sütun listesini kalıcı hale getirdiğinize göre, tahmin sırasında eksik değerleri kolayca ele alabilirsiniz. Model sütunlarını uygulama başlarken yüklemeniz gerekecek.

@app.route('/predict', methods=['POST']) # Your API endpoint URL would consist /predict
def predict():
    if lr:
        try:
            json_ = request.json
            query = pd.get_dummies(pd.DataFrame(json_))
            query = query.reindex(columns=model_columns, fill_value=0)

            prediction = list(lr.predict(query))

            return jsonify({'prediction': prediction})

        except:

            return jsonify({'trace': traceback.format_exc()})
    else:
        print ('Train the model first')
        return ('No model here to use')

"/predict" API’sine gerekli tüm öğeleri dahil ettiniz ve şimdi sadece ana sınıfı yazmanız gerekiyor.

if __name__ == '__main__':
    try:
        port = int(sys.argv[1]) # This is for a command-line argument
    except:
        port = 12345 # If you don't provide any port then the port will be set to 12345
    lr = joblib.load(model_file_name) # Load "model.pkl"
    print ('Model loaded')
    model_columns = joblib.load(model_columns_file_name) # Load "model_columns.pkl"
    print ('Model columns loaded')
    app.run(port=port, debug=True)

API’niz artık barındırılmaya hazır. Ancak daha ileri gitmeden önce, bu noktaya kadar yaptıklarınızı özetleyelim:

Hepsini bir araya getirme:

• Titanic veri kümesini yüklediniz ve dört özelliği seçtiniz.
• Gerekli veri önişlemesini yaptınız.
• Bir Lojistik Regresyon sınıflandırıcısı oluşturup serileştirdiniz.
• Beklenenden az sütun sorununa çözüm olarak, eğitimdeki tüm sütunları da serileştirdiniz.
• Ardından, bir kişinin yaşı, cinsiyeti ve biniş limanı bilgisi verildiğinde gemi kazasında hayatta kalıp kalmadığını tahmin edecek basit bir Flask API’si yazdınız.

Hiçbir şeyi kaçırmamanız için tüm kodu tek bir yerde toplayalım. Ayrıca, Lojistik Regresyon model kodunuz ile Flask API kodunuzu ayrı .py dosyalarına ayırmanız iyi bir programlama uygulamasıdır.

Dolayısıyla model.py dosyanız aşağıdaki gibi görünmelidir:

# Import dependencies
import pandas as pd
import numpy as np

# Load the dataset in a dataframe object and include only four features as mentioned
url = "http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
df = pd.read_csv(url)
include = ['Age', 'Sex', 'Embarked', 'Survived'] # Only four features
df_ = df[include]

# Data Preprocessing
categoricals = []
for col, col_type in df_.dtypes.iteritems():
     if col_type == 'O':
          categoricals.append(col)
     else:
          df_[col].fillna(0, inplace=True)

df_ohe = pd.get_dummies(df_, columns=categoricals, dummy_na=True)

# Logistic Regression classifier
from sklearn.linear_model import LogisticRegression
dependent_variable = 'Survived'
x = df_ohe[df_ohe.columns.difference([dependent_variable])]
y = df_ohe[dependent_variable]
lr = LogisticRegression()
lr.fit(x, y)

# Save your model
from sklearn.externals import joblib
joblib.dump(lr, 'model.pkl')
print("Model dumped!")

# Load the model that you just saved
lr = joblib.load('model.pkl')

# Saving the data columns from training
model_columns = list(x.columns)
joblib.dump(model_columns, 'model_columns.pkl')
print("Models columns dumped!")

api.py dosyanız ise aşağıdaki gibi görünmelidir:

# Dependencies
from flask import Flask, request, jsonify
from sklearn.externals import joblib
import traceback
import pandas as pd
import numpy as np

# Your API definition
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if lr:
        try:
            json_ = request.json
            print(json_)
            query = pd.get_dummies(pd.DataFrame(json_))
            query = query.reindex(columns=model_columns, fill_value=0)

            prediction = list(lr.predict(query))

            return jsonify({'prediction': str(prediction)})

        except:

            return jsonify({'trace': traceback.format_exc()})
    else:
        print ('Train the model first')
        return ('No model here to use')

if __name__ == '__main__':
    try:
        port = int(sys.argv[1]) # This is for a command-line input
    except:
        port = 12345 # If you don't provide any port the port will be set to 12345

    lr = joblib.load("model.pkl") # Load "model.pkl"
    print ('Model loaded')
    model_columns = joblib.load("model_columns.pkl") # Load "model_columns.pkl"
    print ('Model columns loaded')

    app.run(port=port, debug=True)

Epey derli toplu! Şimdi bu API’yi Postman adlı bir API istemcisinde test edeceksiniz. Sadece model.py ve api.py dosyalarının aynı dizinde olduğundan ve test etmeden önce her ikisini de derlediğinizden emin olun. Aşağıdaki terminal görüntüsü, her iki .py dosyası da başarıyla derlendikten sonra alınmıştır.

Tüm dosyalarınız başarıyla derlendiyse, dizin yapısı aşağıdaki gibi olmalıdır:

Not: IPYNB dosyası isteğe bağlıdır.

API’nizi Postman’de Test Etme

API’nizi test etmek için bir tür API istemcisine ihtiyacınız olacak. Postman, tartışmasız en iyilerden biridir. Yukarıdaki bağlantıdan Postman’i kolayca indirebilirsiniz.

En son sürümü indirdiyseniz Postman arayüzü aşağıdaki gibi görünür:

Flask sunucusunu başarıyla başlattıktan sonra, Postman’e doğru URL’yi doğru port numarası ile girmeniz gerekir. Aşağıdakine benzer görünmelidir:

Tebrikler! İlk makine öğrenimi API’nizi oluşturdunuz.

API’niz, bir yolcunun age, sex ve embarked bilgileri verildiğinde Titanic kazasında hayatta kalıp kalmadığını tahmin edebilir. Artık arkadaşınız, bunu ön yüz kodundan çağırabilir ve API çıktısını ilgi çekici bir şeye dönüştürebilir.

Daha İleriye Taşımak:

Bu eğitimde, tam yığın Veri Bilimcisinin en kritik sektör becerilerinden birini, yani bir makine öğrenimi modelinden API oluşturmayı ele aldınız. API son derece basit olsa da, ayrıntılardaki püf noktaları öğrenmek için her zaman en basit şeylerle başlamak en iyisidir.

Bunu geliştirmek için çok daha fazlasını yapabilirsiniz. Düşünebileceğiniz olası seçenekler:

• Veriyle bir Lojistik Regresyon sınıflandırıcısı eğiten bir "/train" API’si yazın.
• keras kullanarak bir Sinir Ağı modeli kodlayın ve bundan bir API oluşturun.
• API’nizi Bulut üzerinde barındırın ki tüketilebilsin.
• Daha ileri seviyelere taşımak için, çeşitli endüstri standart yaklaşımları tartışan bu Machine Learning Mastery bloguna başvurabilirsiniz.

Burada olanaklar ve fırsatlar çok büyük. Sizin için en uygun olanları dikkatlice seçmeniz yeterlidir.

Python’da Makine Öğrenimi hakkında daha fazla bilgi edinmek isterseniz, DataCamp’in Python’da Makine Öğrenimi için Önişleme kursunu alın ve Makine Öğrenimi Temelleri - Normlar eğitimimize göz atın.

Kaynakça:

Bu blog yazılırken başvurulan bazı kaynaklar şunlardır:

• Flask: Python Web Servisleri Oluşturma
• Konuya dair bir Quora başlığı