Mengubah Model Machine Learning menjadi API di Python

Flask – Kerangka Kerja Web Services di Python:

Sekarang, Anda mungkin berpikir apa itu web service? Web service adalah bentuk API yang mengasumsikan bahwa API dihosting di atas server dan dapat dikonsumsi. Web API, Web Service - istilah-istilah ini umumnya digunakan secara bergantian.

Mengenai Flask, ini adalah kerangka kerja pengembangan web service di Python. Bukan satu-satunya di Python, ada beberapa lainnya seperti Django, Falcon, Hug, dll. Namun Anda akan menggunakan Flask untuk tutorial ini. Untuk mempelajari Flask, Anda dapat merujuk ke tutorial ini.

Jika Anda mengunduh distribusi Anaconda, Anda sudah memiliki Flask yang terpasang. Jika tidak, Anda harus memasangnya sendiri dengan:

pip install flask

Flask sangat minimal. Flask menjadi favorit di kalangan pengembang Python karena banyak alasan. Kerangka kerja Flask hadir dengan server web ringan bawaan yang memerlukan konfigurasi minimal, dan dapat dikendalikan dari kode Python Anda. Ini salah satu alasan mengapa Flask begitu populer.

Kode berikut menunjukkan keminimalisan Flask dengan cara yang baik. Kode ini digunakan untuk membuat Web-API sederhana yang ketika menerima URL tertentu akan menghasilkan keluaran spesifik.

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)

Setelah dijalankan, Anda dapat menavigasi ke alamat web (masukkan alamat tersebut pada Peramban Web) yang ditampilkan di terminal, dan mengamati hasilnya.

Beberapa poin:

• Jupyter Notebook sangat bagus untuk hal-hal terkait markdown, R, dan Python. Namun saat membangun server web, bisa saja berperilaku tidak konsisten. Jadi, sebaiknya tulis kode Flask di editor teks seperti Sublime dan jalankan kodenya dari terminal/command prompt.

• Pastikan Anda tidak menamai berkas sebagai flask.py.

• Flask berjalan pada port 5000 secara default. Terkadang, server Flask berhasil berjalan pada port ini, tetapi saat Anda memanggil URL (yang ditampilkan server di terminal) di peramban web atau klien API seperti Postman, Anda mungkin tidak mendapatkan keluaran. Pertimbangkan situasi berikut:

• Menurut Flask, servernya telah berhasil dimulai pada port 5000, tetapi ketika URL tersebut dipanggil di peramban, tidak ada yang dikembalikan. Ini bisa jadi kasus konflik nomor port. Dalam kasus ini, mengganti port default 5000 ke nomor port yang Anda inginkan adalah pilihan yang baik. Anda dapat melakukannya dengan:

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

• Dalam hal itu, server Flask akan terlihat seperti berikut:

Sekarang, mari telusuri langkah demi langkah kode yang Anda tulis:

• Anda membuat instance kelas Flask dan meneruskan variabel "name" (yang diisi sendiri oleh Python). Variabel ini akan bernilai "main", jika berkas ini dijalankan langsung melalui Python sebagai skrip. Jika Anda mengimpornya, nilai "name" akan menjadi nama berkas yang Anda impor. Misalnya, jika Anda memiliki test.py dan run.py, dan Anda mengimpor test.py ke run.py maka nilai "name" dari test.py adalah test (app = Flask(test)).

• Di atas definisi metode hello(), terdapat @app.route(""). route() adalah sebuah decorator yang memberi tahu Flask URL mana yang harus memicu fungsi yang didefinisikan sebagai hello().

• Metode hello() bertanggung jawab menghasilkan keluaran (Welcome to machine learning model APIs!) setiap kali API Anda dipanggil dengan benar (atau dikonsumsi). Dalam kasus ini, membuka peramban web dengan localhost:5000/ akan menghasilkan keluaran yang dimaksud (dengan asumsi server flask berjalan pada port 5000).

Anda sekarang akan mempelajari beberapa hal yang perlu diingat jika Anda mengubah model machine learning (dibangun menggunakan scikit-learn) menjadi API Flask.

Model Scikit-learn dengan Flask

Membuat model machine learning dari yang sangat sederhana hingga sangat kompleks belum pernah semudah ini di Python dengan scikit-learn. Namun ada beberapa poin yang harus Anda ingat tentang scikit-learn:

• Scikit-learn adalah pustaka Python yang menyediakan alat sederhana dan efisien untuk penambangan data dan analisis data. Scikit-learn memiliki modul-modul utama berikut:
  • Clustering
  • Regression
  • Classification
  • Dimensionality Reduction
  • Model selection
  • Preprocessing

(Jangan lupa melihat kursus DataCamp Supervised Learning with scikit-learn yang diajarkan oleh pengembang inti scikit-learn - Andreas Müller)

• Scikit-learn mendukung serialisasi dan deserialisasi model yang Anda latih menggunakan scikit-learn. Ini menghemat waktu Anda untuk melatih ulang model. Dengan salinan model ter-serialisasi yang dibuat menggunakan scikit-learn, Anda dapat menulis API Flask.
  
  
• Model scikit-learn memerlukan data dalam format numerik. Itulah sebabnya, jika dataset berisi fitur kategorikal yang non-numerik, penting untuk mengonversinya menjadi numerik. Untuk transformasi ini, scikit-learn menyediakan utilitas seperti LabelEncoder, OneHotEncoder, dll. Ini dapat ditemukan di modul sklearn.preprocessing.
  
  
• Model scikit-learn tidak bisa menangani nilai hilang secara implisit. Anda perlu menangani nilai hilang dalam dataset Anda sendiri, lalu Anda dapat memberikannya ke model. Untuk menangani nilai hilang, scikit-learn menyediakan beragam utilitas yang dapat ditemukan di modul sklearn.preprocessing.

Label encoding dan nilai hilang adalah langkah prapemrosesan data penting yang sangat esensial untuk membangun model machine learning yang baik. Jika Anda ingin mempelajari lebih lanjut, lihat kursus berikut yang ditawarkan oleh DataCamp:

• Preprocessing for Machine Learning in Python

Untuk tutorial ini, Anda akan menggunakan dataset Titanic yang merupakan salah satu dataset paling populer karena banyak alasan seperti - dataset ini berisi berbagai jenis variabel yang baik, dan dataset ini memiliki nilai hilang, dll. Tutorial DataCamp ini mencakup analisis yang sangat baik terhadap dataset tersebut, dan datasetnya dapat diunduh dari sini.

Dataset ini berkaitan dengan masalah klasifikasi untuk memprediksi apakah seorang penumpang akan selamat atau tidak berdasarkan beberapa informasi tentang dirinya.

Catatan: Variabel dan Fitur adalah istilah yang digunakan secara bergantian di banyak bagian tutorial ini.

Untuk menyederhanakan lebih jauh, Anda hanya akan menggunakan empat variabel: age, sex, embarked, dan survived di mana survived adalah label kelas.

# 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" dan "Embarked" adalah fitur kategorikal dengan nilai non-numerik dan karena itu memerlukan beberapa transformasi numerik. Fitur “Age” memiliki nilai hilang. Nilai-nilai ini dapat diimputasi dengan statistik ringkas seperti median atau rata-rata. Nilai hilang bisa sangat bermakna, dan layak ditelusuri apa yang mereka wakili dalam aplikasi dunia nyata.

Scikit-learn memperlakukan sel yang tidak berisi apa pun sebagai NaN. Di sini, Anda hanya akan mengganti NaN dengan 0, dan Anda akan menulis fungsi pembantu untuk itu.

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

Baris-baris kode di atas melakukan hal berikut:

• Mengiterasi semua kolom dalam dataframe df dan menambahkan kolom (dengan nilai non-numerik) ke daftar categorical.

• Jika kolom tidak memiliki nilai non-numerik (yang dalam kasus ini hanya Age), maka akan diperiksa apakah memiliki nilai hilang atau tidak dan mengisinya dengan 0.

  Mengisi NaN dengan satu nilai dapat menimbulkan konsekuensi yang tidak diinginkan, terutama jika jumlah yang Anda gunakan untuk mengganti NaN berada dalam rentang yang teramati untuk variabel numerik tersebut. Karena nol bukan nilai usia yang teramati dan sah, Anda tidak memperkenalkan bias, seperti jika Anda menggunakan misalnya 36! - Sumber

Sekarang setelah Anda menangani nilai hilang dan memisahkan kolom non-numerik, Anda siap mengubahnya menjadi numerik. Anda akan melakukannya dengan menggunakan One Hot Encoding. Pandas menyediakan metode sederhana get_dummies() untuk membuat variabel OHE untuk sebuah dataframe.

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

Saat Anda menggunakan OHE, sebuah kolom baru dibuat untuk setiap kombinasi kolom/nilai, dalam format column_value. Misalnya - untuk variabel “Embarked”, OHE akan menghasilkan “Embarked_C”, “Embarked_Q”, “Embarked_S”, dan “Embarked_nan”.

Sekarang setelah Anda berhasil melakukan prapemrosesan dataset, Anda siap melatih model machine learning. Anda akan menggunakan klasifikator Logistic Regression untuk ini.

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)

Anda telah membangun model machine learning Anda. Sekarang Anda akan menyimpan model ini. Secara teknis, Anda akan melakukan serialisasi pada model ini. Dalam Python, ini disebut Pickling.

Menyimpan Model: Serialisasi dan Deserialisasi

Anda akan menggunakan joblib dari sklearn untuk ini.

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

['model.pkl']

Model Logistic Regression kini telah dipertahankan. Anda dapat memuat model ini ke memori dengan satu baris kode. Memuat kembali model ke ruang kerja Anda dikenal sebagai Deserialisasi.

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

Anda sekarang siap menggunakan Flask untuk menyajikan model yang telah dipertahankan. Anda sudah melihat betapa minimalisnya Flask untuk memulai.

Membuat API dari Model Machine Learning menggunakan Flask

Untuk menyajikan model Anda dengan Flask, Anda akan melakukan dua hal berikut:

• Memuat model yang sudah dipertahankan ke memori saat aplikasi dimulai,
• Membuat endpoint API yang menerima variabel input, mengubahnya ke format yang sesuai, dan mengembalikan prediksi.

Lebih khusus lagi, contoh input Anda ke API akan terlihat seperti berikut:

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

(yang merupakan list JSON dari input)

dan API Anda akan menghasilkan keluaran seperti berikut:

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

Prediksi menunjukkan status keselamatan di mana 0 mewakili Tidak dan 1 mewakili Ya.

JSON adalah singkatan dari JavaScript Object Notation, dan ini adalah salah satu format pertukaran data yang paling banyak digunakan. Jika Anda membutuhkan pengenalan singkat, silakan ikuti tutorial ini.

Mari tulis fungsi predict() yang akan melakukan:

• Memuat model yang dipertahankan ke memori saat aplikasi dimulai,
• Membuat endpoint API yang menerima variabel input, mengubahnya ke format yang sesuai, dan mengembalikan prediksi.

Anda sudah melihat cara memuat model yang dipertahankan. Sekarang, Anda akan fokus pada cara menggunakannya untuk memprediksi status keselamatan setelah menerima input.

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)})

Luar biasa! Namun Anda memiliki sedikit masalah di sini.

Fungsi yang Anda tulis hanya akan berfungsi dalam kondisi di mana permintaan yang masuk berisi semua kemungkinan nilai untuk variabel kategorikal yang mungkin tidak selalu terjadi di waktu nyata. Jika permintaan yang masuk tidak menyertakan semua kemungkinan nilai variabel kategorikal maka sesuai definisi metode predict() saat ini, get_dummies() akan menghasilkan dataframe yang memiliki lebih sedikit kolom daripada yang diharapkan oleh klasifikator, yang akan mengakibatkan galat saat runtime.

Untuk mengatasi masalah ini, Anda juga akan mempertahankan daftar kolom saat pelatihan model. Anda dapat men-serialisasi objek Python apa pun ke berkas .pkl. Anda akan menggunakan joblib dengan cara yang sama seperti sebelumnya.

(Perlu diingat, seperti dibahas sebelumnya selalu lebih baik melakukan semua pengodean tingkat server di editor teks lalu menjalankannya dari terminal)

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

['model_columns.pkl']

Karena Anda telah mempertahankan daftar kolom, Anda dapat menangani nilai yang hilang pada saat prediksi. Anda harus memuat kolom model saat aplikasi dimulai.

@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')

Anda telah menyertakan semua elemen yang diperlukan dalam API "/predict", dan sekarang Anda hanya perlu menulis kelas utama.

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 Anda kini siap untuk dihosting. Namun sebelum melangkah lebih jauh, mari rekap semua yang telah Anda lakukan hingga titik ini:

Menggabungkan semuanya:

• Anda memuat dataset Titanic dan memilih empat fitur.
• Anda melakukan prapemrosesan data yang diperlukan.
• Anda membangun klasifikator Logistic Regression dan men-serialisasikannya.
• Anda juga men-serialisasi semua kolom dari pelatihan sebagai solusi untuk jumlah kolom yang kurang dari yang diharapkan, yakni dengan mempertahankan daftar kolom dari pelatihan.
• Kemudian Anda menulis API sederhana menggunakan Flask yang akan memprediksi apakah seseorang selamat dari karamnya kapal berdasarkan informasi usia, jenis kelamin, dan embarkasi.

Mari tempatkan semua kode di satu tempat agar Anda tidak melewatkan apa pun. Selain itu, merupakan praktik pemrograman yang baik jika Anda memisahkan kode model Logistic Regression dan kode API Flask Anda ke dalam berkas .py terpisah.

Jadi model.py Anda seharusnya terlihat seperti berikut:

# 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 Anda seharusnya terlihat seperti berikut:

# 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)

Cukup rapi! Sekarang Anda akan menguji API ini di klien API bernama Postman. Pastikan model.py dan api.py berada di direktori yang sama dan juga pastikan Anda telah mengompilasi keduanya sebelum pengujian. Lihat cuplikan terminal berikut yang diambil setelah kedua berkas .py berhasil dikompilasi.

Jika semua berkas Anda berhasil dikompilasi, struktur direktori seharusnya seperti berikut:

Catatan: Berkas IPYNB bersifat opsional.

Menguji API Anda di Postman

Untuk menguji API Anda, Anda memerlukan semacam klien API. Postman tidak diragukan lagi salah satu yang terbaik. Anda dapat dengan mudah mengunduh Postman dari tautan di atas.

Antarmuka Postman terlihat seperti berikut jika Anda mengunduh versi terbaru:

Setelah Anda berhasil menjalankan server Flask, Anda kemudian perlu memasukkan URL yang tepat dengan nomor port yang benar di Postman. Seharusnya terlihat mirip seperti berikut:

Selamat! Anda baru saja membangun API machine learning pertama Anda.

API Anda dapat memprediksi apakah seorang penumpang selamat dari karamnya Titanic berdasarkan informasi age, sex dan embarked. Kini, teman Anda dapat memanggilnya dari kode front-end mereka dan memproses keluaran API menjadi sesuatu yang menarik.

Melangkah Lebih Jauh:

Dalam tutorial ini, Anda membahas salah satu keterampilan industri paling vital dari seorang Data Scientist full-stack, yaitu membangun API dari model machine learning. Meskipun API-nya sangat sederhana, selalu lebih baik memulai dari hal yang paling sederhana agar Anda memahami seluk-beluknya.

Anda dapat melakukan lebih banyak hal untuk meningkatkannya. Opsi yang mungkin ingin Anda pertimbangkan:

• Menulis API "/train" yang akan melatih klasifikator Logistic Regression dengan data.
• Membuat model Neural Network menggunakan keras dan membangun API darinya.
• Menjadikan API Anda tersedia di Cloud agar dapat dikonsumsi.
• Untuk membawa hal ini ke tingkat yang lebih lanjut, Anda dapat merujuk ke blog Machine Learning Mastery ini yang membahas beberapa pendekatan berkelas industri.

Peluang dan kemungkinan di sini sangat besar. Anda hanya perlu dengan cermat memilih yang paling sesuai untuk Anda.

Jika Anda ingin mempelajari lebih lanjut tentang Machine Learning di Python, ikuti kursus DataCamp Preprocessing for Machine Learning in Python dan lihat tutorial kami Machine Learning Basics - The Norms.

Referensi:

Berikut beberapa referensi yang digunakan saat menulis blog ini:

• Flask: Building Python Web Services
• Thread Quora tentang topik ini