Model Machine Learning adalah proyek yang menarik. Pelajari cara develop model pertama Anda yang diinginkan oleh perusahaan.
Hai semuanya! Saya yakin Anda membaca artikel ini karena tertarik dengan model machine learning dan ingin membuatnya.
Anda mungkin sudah pernah mencoba mengembangkan model machine learning sebelumnya atau benar-benar baru dengan konsep ini. Apapun pengalaman Anda, artikel ini akan memandu Anda melalui praktik terbaik untuk mengembangkan model machine learning.
Dalam artikel ini, kita akan mengembangkan model klasifikasi prediksi Customer Churn dengan mengikuti langkah-langkah berikut:
Pemahaman Bisnis
Pengumpulan dan Persiapan Data
Mengumpulkan Data
Exploratory Data Analysis (EDA) dan Data Cleaning
Feature Selection
3. Membangun Model Machine Learning
Memilih Model yang Tepat
Splitting the Data
Training the Model
Model Evaluation
4. Optimalisasi Model
5. Mendeploy Model
Mari kita mulai membangun model machine learning pertama Anda.
Memahami Dasar-Dasar Machine Learning
Sebelum kita masuk ke pengembangan model machine learning, mari kita jelaskan secara singkat apa itu machine learning, jenis-jenis machine learning, dan beberapa terminologi yang akan kita gunakan dalam artikel ini.
Pertama, mari kita bahas jenis-jenis model machine learning yang bisa kita kembangkan. Ada empat jenis utama Machine Learning yang sering dikembangkan:
Supervised Machine Learning adalah algoritma machine learning yang belajar dari dataset yang diberi label. Berdasarkan output yang benar, model belajar dari pola dan mencoba memprediksi data baru. Ada dua kategori dalam Supervised Machine Learning: Classification (prediksi kategori) dan Regression (prediksi numerik).
Unsupervised Machine Learning adalah algoritma yang mencoba menemukan pola dari data tanpa arahan. Tidak seperti supervised machine learning, model tidak dipandu oleh data yang diberi label. Jenis ini memiliki dua kategori umum: Clustering (Segmentasi Data) dan Dimensionality Reduction (Pengurangan Fitur).
Semi-supervised Machine Learning menggabungkan dataset berlabel dan tidak berlabel, di mana dataset berlabel memandu model dalam mengidentifikasi pola pada data yang tidak berlabel. Contoh paling sederhana adalah model self-training yang bisa memberi label data yang tidak berlabel berdasarkan pola data berlabel.
Reinforcement Learning adalah algoritma machine learning yang bisa berinteraksi dengan lingkungan dan bereaksi berdasarkan tindakan (mendapatkan reward atau punishment). Algoritma ini akan memaksimalkan hasil dengan sistem reward dan menghindari hasil buruk dengan punishment. Contoh penerapan model ini adalah self-driving car.
Anda juga perlu mengetahui beberapa terminologi untuk mengembangkan model machine learning:
Features: Variabel input yang digunakan untuk membuat prediksi dalam model machine learning.
Labels: Variabel output yang coba diprediksi oleh model.
Data Splitting: Proses pemisahan data menjadi set-set yang berbeda.
Training Set: Data yang digunakan untuk melatih model machine learning.
Test Set: Data yang digunakan untuk mengevaluasi kinerja model yang telah dilatih.
Validation Set: Data yang digunakan selama proses pelatihan untuk menyetel hyperparameters.
Exploratory Data Analysis (EDA): Proses menganalisis dan memvisualisasikan dataset untuk merangkum informasi dan menemukan pola.
Models: Hasil dari proses Machine Learning. Mereka adalah representasi matematis dari pola dan hubungan dalam data.
Overfitting: Terjadi ketika model terlalu terperinci dan belajar dari noise data. Model dapat memprediksi dengan baik dalam training set tetapi tidak dalam test set.
Underfitting: Terjadi ketika model terlalu sederhana untuk menangkap pola dasar dalam data. Kinerja model dalam training set dan test set bisa lebih baik lagi.
Hyperparameters: Pengaturan konfigurasi yang digunakan untuk menyempurnakan model dan diatur sebelum pelatihan dimulai.
Cross-validation: Teknik untuk mengevaluasi model dengan membagi sampel asli menjadi training set dan validation set beberapa kali.
Feature Engineering: Menggunakan pengetahuan domain untuk mendapatkan fitur baru dari data mentah.
Model Training: Proses mempelajari parameter model menggunakan training data.
Model Evaluation: Menilai kinerja model yang telah dilatih menggunakan metrik machine learning seperti accuracy, precision, dan recall.
Model Deployment: Membuat model yang telah dilatih bisa digunakan dalam lingkungan produksi.
Dengan semua pengetahuan dasar ini, mari kita belajar mengembangkan model machine learning pertama kita.
1. Pemahaman Bisnis
Sebelum pengembangan model machine learning, kita harus memahami mengapa kita harus mengembangkan model tersebut. Oleh karena itu, memahami apa yang diinginkan bisnis perlu dilakukan untuk memastikan model tersebut valid.
Pemahaman bisnis biasanya membutuhkan diskusi dengan pemangku kepentingan terkait. Namun, karena tutorial ini tidak memiliki pengguna bisnis untuk model machine learning, kita asumsikan kebutuhan bisnis kita sendiri.
Seperti yang telah disebutkan sebelumnya, kita akan mengembangkan model prediksi Customer Churn. Dalam hal ini, bisnis perlu menghindari churn berkelanjutan dari perusahaan dan ingin mengambil tindakan pada pelanggan dengan kemungkinan tinggi untuk churn.
Dengan kebutuhan bisnis di atas, kita membutuhkan metrik khusus untuk mengukur apakah model berfungsi dengan baik. Ada banyak pengukuran, tetapi saya mengusulkan menggunakan metrik Recall.
Dari sisi keuangan, mungkin lebih bermanfaat menggunakan Recall, karena akan meminimalkan False Negative atau mengurangi jumlah prediksi yang tidak churn padahal sebenarnya churn. Tentu saja, kita dapat mencoba mencapai keseimbangan dengan menggunakan metrik F1.
Dengan pemikiran tersebut, mari kita mulai bagian pertama dari tutorial kita.
2. Pengumpulan dan Persiapan Data
Pengumpulan Data
Data adalah inti dari setiap proyek machine learning. Tanpa data, kita tidak bisa memiliki model machine learning untuk dilatih. Oleh karena itu, kita memerlukan data berkualitas dengan persiapan yang tepat sebelum kita memasukkannya ke dalam algoritma machine learning.
Dalam dunia nyata, data yang bersih tidak bisa diperoleh dengan mudah. Seringkali kita perlu mengumpulkannya melalui aplikasi, survei, dan banyak sumber lainnya sebelum menyimpannya di tempat penyimpanan data. Namun, tutorial ini tidak mencakup pengumpulan dataset karena kami menggunakan data bersih yang sudah ada.
Dalam kasus kita, kita akan menggunakan data Telco Customer Churn dari Kaggle. Ini adalah data klasifikasi open-source mengenai riwayat pelanggan di industri telekomunikasi dengan label churn.
Exploratory Data Analysis (EDA) dan Data Cleaning
Mari kita mulai dengan meninjau dataset kita. Saya mengasumsikan pembaca sudah memiliki pengetahuan dasar tentang Python dan dapat menggunakan paket Python di notebook mereka. Untuk mempermudah, saya membuat tutorial ini menggunakan Anaconda environment.
Untuk memahami data yang kita miliki, kita perlu memuatnya ke dalam paket Python untuk manipulasi data. Paket paling terkenal dan yang akan kita gunakan adalah Pandas. Kita bisa menggunakan kode berikut untuk memuat dan meninjau data dengan format CSV.
import pandas as pd
df = pd.read_csv('WA_Fn-UseC_-Telco-Customer-Churn.csv')
df.head()
Selanjutnya, kita akan mengeksplorasi data untuk memahami dataset kita. Berikut adalah beberapa tindakan yang akan kita lakukan untuk proses EDA:
Memeriksa fitur dan summary statistics.
Memeriksa missing value dalam fitur.
Menganalisis distribusi label (Churn).
Memplot histogram untuk fitur numerik dan bar plot untuk fitur kategorikal.
Memplot heatmap korelasi untuk fitur numerik.
Menggunakan box plot untuk mengidentifikasi distribusi dan potensial outlier.
Pertama, kita akan memeriksa fitur dan summary statistics. Dengan Pandas, kita bisa melihat fitur dataset menggunakan kode berikut.
Kita juga akan mendapatkan ssummary statistics dataset dengan kode berikut.
# Dapatkan informasi dasar tentang dataset
df.info()Output>>
RangeIndex: 7043 entries, 0 to 7042
Data columns (total 21 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 customerID 7043 non-null object
1 gender 7043 non-null object
2 SeniorCitizen 7043 non-null int64
3 Partner 7043 non-null object
4 Dependents 7043 non-null object
5 tenure 7043 non-null int64
6 PhoneService 7043 non-null object
7 MultipleLines 7043 non-null object
8 InternetService 7043 non-null object
9 OnlineSecurity 7043 non-null object
10 OnlineBackup 7043 non-null object
11 DeviceProtection 7043 non-null object
12 TechSupport 7043 non-null object
13 StreamingTV 7043 non-null object
14 StreamingMovies 7043 non-null object
15 Contract 7043 non-null object
16 PaperlessBilling 7043 non-null object
17 PaymentMethod 7043 non-null object
18 MonthlyCharges 7043 non-null float64
19 TotalCharges 7043 non-null object
20 Churn 7043 non-null object
dtypes: float64(1), int64(2), object(18)
memory usage: 1.1+ MBKita juga bisa mendapatkan summary statistics dari dataset dengan ode berikut.
# Mendapatkan numerical summary statistics dari dataset
df.describe()
# Mendapatkan categorical summary statistics dari dataset
df.describe(exclude = 'number')
Dari informasi di atas, kita tahu bahwa kita memiliki 19 fitur dengan satu target fitur (Churn). Dataset berisi 7043 baris, dan sebagian besar dataset adalah kategorikal.
Mari kita periksa missing value.
# Memeriksa missing values
print(df.isnull().sum())Output>>
Missing Values:
customerID 0
gender 0
SeniorCitizen 0
Partner 0
Dependents 0
tenure 0
PhoneService 0
MultipleLines 0
InternetService 0
OnlineSecurity 0
OnlineBackup 0
DeviceProtection 0
TechSupport 0
StreamingTV 0
StreamingMovies 0
Contract 0
PaperlessBilling 0
PaymentMethod 0
MonthlyCharges 0
TotalCharges 0
Churn 0Dataset kita tidak memiliki missing value, jadi kita tidak perlu melakukan aktivitas pengolahan missing value.
Kemudian, kita akan memeriksa variabel target untuk melihat apakah kita memiliki kasus imbalance (ketidakseimbangan).
print(df['Churn'].value_counts())
Output>>
Distribution of Target Variable:
No 5174
Yes 1869Ada sedikit ketidakseimbangan, karena hanya ada sekitar 25% churn dibandingkan dengan kasus non-churn.
Mari kita lihat distribusi fitur lainnya, dimulai dengan fitur numerik. Namun, kita juga akan mengubah fitur TotalCharges menjadi kolom numerik, karena fitur ini seharusnya numerik bukan kategori. Selain itu, fitur SeniorCitizen harusnya kategorikal sehingga saya akan mengubahnya menjadi string. Juga, karena fitur Churn adalah kategorikal, kita akan mengembangkan fitur baru yang menunjukkan itu sebagai kolom numerik.
import numpy as np
df['TotalCharges'] = df['TotalCharges'].replace('', np.nan)
df['TotalCharges'] = pd.to_numeric(df['TotalCharges'], errors='coerce').fillna(0)
df['SeniorCitizen'] = df['SeniorCitizen'].astype('str')
df['ChurnTarget'] = df['Churn'].apply(lambda x: 1 if x=='Yes' else 0)
df['ChurnTarget'] = df['Churn'].apply(lambda x: 1 if x=='Yes' else 0)
num_features = df.select_dtypes('number').columns
df[num_features].hist(bins=15, figsize=(15, 6), layout=(2, 5))
Kita juga akan menyediakan plotting fitur kategorikal kecuali customerID, karena itu adalah pengidentifikasi dengan nilai unik.
import matplotlib.pyplot as plt
# Plot distribution of categorical features
cat_features = df.drop('customerID', axis =1).select_dtypes(include='object').columns
plt.figure(figsize=(20, 20))
for i, col in enumerate(cat_features, 1):
plt.subplot(5, 4, i)
df[col].value_counts().plot(kind='bar')
plt.title(col)
Kemudian kita akan melihat korelasi antara fitur numerik dengan kode berikut.
import seaborn as sns
# Plot correlations between numerical features
plt.figure(figsize=(10, 8))
sns.heatmap(df[num_features].corr())
plt.title('Correlation Heatmap')
Korelasi di atas didasarkan pada Pearson Correlation, korelasi linier antara satu fitur dengan firur lainnya. Kita juga dapat melakukan analisis korelasi untuk analisis kategorikal dengan Cramer’s V. Untuk mempermudah analisis, kita akan menginstal paket Python Dython yang dapat membantu analisis kita.
pip install dythonSetelah paket diinstal, kita akan melakukan analisis korelasi dengan kode berikut.
from dython.nominal import associations
# Hitung Cramer's V dan matriks korelasi
assoc = associations(df[cat_features], nominal_columns='all', plot=False)
corr_matrix = assoc['corr']
# Plot heatmap
plt.figure(figsize=(14, 12))
sns.heatmap(corr_matrix)
Terakhir, kita akan memeriksa outlier numerik dengan box plot berdasarkan Interquartile Range (IQR).
# Plot box plots to identify outliers
plt.figure(figsize=(20, 15))
for i, col in enumerate(num_features, 1):
plt.subplot(4, 4, i)
sns.boxplot(y=df[col])
plt.title(col)
Dari analisis di atas, kita dapat melihat bahwa kita tidak perlu menangani missing value atau outlier. Langkah selanjutnya adalah melakukan Feature Selection (seleksi fitur) untuk model machine learning kita, karena kita hanya ingin fitur yang mempengaruhi prediksi dan dapat dijalankan dalam bisnis.
Feature Selection
Ada banyak cara untuk melakukan feature selection, biasanya dilakukan dengan menggabungkan pengetahuan bisnis dan aplikasi teknis. Namun, tutorial ini hanya akan menggunakan analisis korelasi yang telah kita lakukan sebelumnya untuk melakukan feature selection.
Pertama, mari kita pilih fitur numerik berdasarkan analisis korelasi.
target = 'ChurnTarget'
num_features = df.select_dtypes(include=[np.number]).columns.drop(target)
# Menghitung korelasi
correlations = df[num_features].corrwith(df[target])
# Atur threshold untuk seleksi fitur
threshold = 0.3
selected_num_features = correlations[abs(correlations) > threshold].index.tolist()Anda dapat mengubah-ubah threshold untuk melihat apakah feature selection mempengaruhi kinerja model. Kita juga akan melakukan feature selection ke fitur kategorikal.
categorical_target = 'Churn'
assoc = associations(df[cat_features], nominal_columns='all', plot=False)
corr_matrix = assoc['corr']
threshold = 0.3
selected_cat_features = corr_matrix[corr_matrix.loc[categorical_target] > threshold ].index.tolist()
del selected_cat_features[-1]Kemudian, kita akan menggabungkan semua fitur yang dipilih dengan kode berikut.
selected_features = []
selected_features.extend(selected_num_features)
selected_features.extend(selected_cat_features)
print(selected_features)Output>>
['tenure',
'InternetService',
'OnlineSecurity',
'TechSupport',
'Contract',
'PaymentMethod']Pada akhirnya, kita memiliki enam fitur yang akan digunakan untuk mengembangkan model machine learning untuk memprediksi customer churn.
3. Membangun Model Machine Learning
Memilih Model yang Tepat
Ada banyak pertimbangan dalam memilih model yang cocok untuk pengembangan machine learning, tetapi selalu bergantung pada kebutuhan bisnis. Beberapa poin yang perlu diingat, diantaranya:
Masalah kasus penggunaan (use-case problem). Apakah itu supervised atau unsupervised, atau apakah itu klasifikasi atau regresi? Apakah itu Multiclass atau Multilabel? Masalah kasus akan menentukan model mana yang dapat digunakan.
Karakteristik data. Apakah itu data tabular, teks, atau gambar? Apakah ukuran dataset besar atau kecil? Apakah dataset mengandung missing values? Bergantung pada dataset, model yang kita pilih bisa berbeda.
Seberapa mudah model untuk diinterpretasikan? Menyeimbangkan interpretabilitas dan kinerja sangat penting untuk bisnis.
Sebagai aturan praktis, sering kali lebih baik memulai dengan model yang lebih sederhana sebagai patokan sebelum melanjutkan ke model yang lebih kompleks. Anda dapat membaca artikel saya sebelumnya tentang model sederhana untuk memahami apa yang dimaksud dengan model sederhana.
Pada tutorial ini, mari kita mulai dengan model linear Logistic Regression untuk pengembangan model.
Splitting the Data
Aktivitas selanjutnya adalah membagi data menjadi training set, test set, dan validation set. Tujuan dari pembagian data selama pelatihan model machine learning adalah untuk memiliki dataset yang bertindak sebagai data yang tidak terlihat (data dari dunia nyata) untuk mengevaluasi model yang tidak bias tanpa kebocoran data.
Untuk membagi data, kita akan menggunakan kode berikut:
from sklearn.model_selection import train_test_split
target = 'ChurnTarget'
X = df[selected_features]
y = df[target]
cat_features = X.select_dtypes(include=['object']).columns.tolist()
num_features = X.select_dtypes(include=['number']).columns.tolist()
# Membagi data menjadi Train, Validation, and Test Set
X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
X_train, X_val, y_train, y_val = train_test_split(X_train_val, y_train_val, test_size=0.25, random_state=42, stratify=y_train_val)Pada kode di atas, kita membagi data menjadi 60% untuk training set dan 20% untuk test set dan validation set. Setelah kita memiliki dataset, selanjutnya kita akan melatih model.
Training the Model
Seperti yang disebutkan sebelumnya, kita akan melatih model Logistic Regression dengan data training kita. Namun, model hanya dapat menerima data numerik, jadi kita harus melakukan data preprocessing. Ini berarti kita perlu mengubah data kategorikal menjadi data numerik.
Sebagai best practice, kita menggunakan pipeline Scikit-Learn untuk memuat semua langkah prepocessing dan pemodelan. Kode berikut memungkinkan Anda melakukan hal itu:
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder
from sklearn.linear_model import LogisticRegression
# Persiapan untuk preprocessing
preprocessor = ColumnTransformer(
transformers=[
('num', 'passthrough', num_features),
('cat', OneHotEncoder(), cat_features)
])
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', LogisticRegression(max_iter=1000))
])
# Melatih model logistic regression
pipeline.fit(X_train, y_train)Pipeline model akan terlihat seperti gambar di bawah ini:
Pipeline Scikit-Learn akan menerima data yang tidak terlihat dan melewati semua langkah preprocessing sebelum masuk ke model. Setelah model selesai dilatih, mari kita evaluasi hasil model kita.
Model Evaluation
Seperti yang disebutkan, kita akan mengevaluasi model dengan fokus pada metrik Recall. Namun, kode berikut menunjukkan semua metrik klasifikasi dasar.
from sklearn.metrics import classification_report
# Evalusi di validation set
y_val_pred = pipeline.predict(X_val)
print("Validation Classification Report:\n", classification_report(y_val, y_val_pred))
# Evalusi di test set
y_test_pred = pipeline.predict(X_test)
print("Test Classification Report:\n", classification_report(y_test, y_test_pred))
Seperti yang kita lihat dari data validation dan test, Recall untuk churn (1) belum terbaik. Itulah mengapa kita bisa mengoptimalkan model untuk mendapatkan hasil terbaik.
4. Optimalisasi Model
Kita harus selalu fokus pada data untuk mendapatkan hasil terbaik. Namun, mengoptimalkan model juga bisa memberikan hasil yang lebih baik. Inilah mengapa kita bisa mengoptimalkan model kita. Salah satu cara untuk mengoptimalkan model adalah melalui optimasi hyperparameter, yang menguji semua kombinasi hyperparameter model untuk menemukan yang terbaik berdasarkan metrik.
Setiap model memiliki satu set hyperparameter yang bisa kita atur sebelum melatihnya. Kita menyebut optimasi hyperparameter sebagai eksperimen untuk melihat kombinasi mana yang terbaik. Untuk melakukannya, kita bisa menggunakan kode berikut:
from sklearn.model_selection import GridSearchCV
# Tentukan model regresi logistik dalam pipeline
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', LogisticRegression(max_iter=1000))
])
# Tentukan hyperparameter untuk GridSearchCV
param_grid = {
'classifier__C': [0.1, 1, 10, 100],
'classifier__solver': ['lbfgs', 'liblinear']
}
# Lakukan Grid Search dengan cross-validation
grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='recall')
grid_search.fit(X_train, y_train)
# Hyperparameters terbaik
print("Best Hyperparameters:", grid_search.best_params_)
# Evaluasi pada validation set
y_val_pred = grid_search.predict(X_val)
print("Validation Classification Report:\n", classification_report(y_val, y_val_pred))
# Evaluasi pada test set
y_test_pred = grid_search.predict(X_test)
print("Test Classification Report:\n", classification_report(y_test, y_test_pred))
Hasilnya mungkin masih belum menunjukkan skor Recall terbaik, tetapi ini masih sesuai prediksi karena kita hanya menggunakan model dasar. Mari kita bereksperimen dengan beberapa model untuk melihat apakah kinerja Recall meningkat. Anda dapat menyesuaikan hyperparameter di bawah ini.
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.metrics import recall_score
# Tentukan model dan parameter grids
models = {
'Logistic Regression': {
'model': LogisticRegression(max_iter=1000),
'params': {
'classifier__C': [0.1, 1, 10, 100],
'classifier__solver': ['lbfgs', 'liblinear']
}
},
'Decision Tree': {
'model': DecisionTreeClassifier(),
'params': {
'classifier__max_depth': [None, 10, 20, 30],
'classifier__min_samples_split': [2, 10, 20]
}
},
'Random Forest': {
'model': RandomForestClassifier(),
'params': {
'classifier__n_estimators': [100, 200],
'classifier__max_depth': [None, 10, 20]
}
},
'SVM': {
'model': SVC(),
'params': {
'classifier__C': [0.1, 1, 10, 100],
'classifier__kernel': ['linear', 'rbf']
}
},
'Gradient Boosting': {
'model': GradientBoostingClassifier(),
'params': {
'classifier__n_estimators': [100, 200],
'classifier__learning_rate': [0.01, 0.1, 0.2]
}
},
'XGBoost': {
'model': XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
'params': {
'classifier__n_estimators': [100, 200],
'classifier__learning_rate': [0.01, 0.1, 0.2],
'classifier__max_depth': [3, 6, 9]
}
},
'LightGBM': {
'model': LGBMClassifier(),
'params': {
'classifier__n_estimators': [100, 200],
'classifier__learning_rate': [0.01, 0.1, 0.2],
'classifier__num_leaves': [31, 50, 100]
}
}
}
results = []
# latih dan evalusi setiap model
for model_name, model_info in models.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', model_info['model'])
])
grid_search = GridSearchCV(pipeline, model_info['params'], cv=5, scoring='recall')
grid_search.fit(X_train, y_train)
# Model fterbaik dari Grid Search
best_model = grid_search.best_estimator_
# Evaluasi pada validation set
y_val_pred = best_model.predict(X_val)
val_recall = recall_score(y_val, y_val_pred, pos_label=1)
# Evaluasi pada test set
y_test_pred = best_model.predict(X_test)
test_recall = recall_score(y_test, y_test_pred, pos_label=1)
# Simpan hasilnya
results.append({
'model': model_name,
'best_params': grid_search.best_params_,
'val_recall': val_recall,
'test_recall': test_recall,
'classification_report_val': classification_report(y_val, y_val_pred),
'classification_report_test': classification_report(y_test, y_test_pred)
})
# Visualisasikan skor recall terbaik
plt.figure(figsize=(10, 6))
model_names = [result['model'] for result in results]
test_recalls = [result['test_recall'] for result in results]
plt.barh(model_names, test_recalls, color='skyblue')
plt.xlabel('Test Recall')
plt.title('Comparison of Test Recall for Different Models')
plt.show()
Hasil Recall mungkin tidak banyak berubah; bahkan model dasar Logistic Regression tampaknya yang terbaik. Kita harus kembali dengan feature selection yang lebih baik jika kita menginginkan hasil yang lebih baik.
Namun, mari kita lanjutkan dengan model Logistic Regression saat ini dan coba mendepoy modelnya.
5. Mendeploy Model
Kita telah membangun model machine learning. Setelah memiliki model, langkah selanjutnya adalah mendepoy modelnya ke produksi. Mari kita simulasi menggunakan API sederhana.
Pertama, mari kita kembangkan kembali model kita dan menyimpannya sebagai objek joblib.
import joblib
best_params = {'classifier__C': 1, 'classifier__solver': 'lbfgs'}
logreg_model = LogisticRegression(C=best_params['classifier__C'], solver=best_params['classifier__solver'], max_iter=1000)
preprocessor = ColumnTransformer(
transformers=[
('num', 'passthrough', num_features),
('cat', OneHotEncoder(), cat_features)
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', logreg_model)
])
pipeline.fit(X_train, y_train)
# Simpan model
joblib.dump(pipeline, 'logreg_model.joblib')Setelah objek model siap, kita akan berpindah ke skrip Python untuk membuat API. Tapi pertama-tama, kita perlu menginstal beberapa paket yang digunakan untuk deploy.
pip install fastapi uvicornKita tidak akan melakukannya di notebook tetapi di IDE seperti Visual Studio Code. Di IDE pilihan Anda, buat skrip Python yang disebut app.py dan masukkan kode berikut ke dalam skrip.
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np
# Memuat model regresi logistik pipeline
model = joblib.load('logreg_model.joblib')
# Tentukan data input untuk model
class CustomerData(BaseModel):
tenure: int
InternetService: str
OnlineSecurity: str
TechSupport: str
Contract: str
PaymentMethod: str
# Membuat FastAPI app
app = FastAPI()
# Tentukan endpoint prediksi
@app.post("/predict")
def predict(data: CustomerData):
# Ubah input data ke dictionary kemudian ke DataFrame
input_data = {
'tenure': [data.tenure],
'InternetService': [data.InternetService],
'OnlineSecurity': [data.OnlineSecurity],
'TechSupport': [data.TechSupport],
'Contract': [data.Contract],
'PaymentMethod': [data.PaymentMethod]
}
import pandas as pd
input_df = pd.DataFrame(input_data)
# Buat predikasi
prediction = model.predict(input_df)
# Return prediksinya
return {"prediction": int(prediction[0])}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)Di command prompt atau terminal Anda, jalankan kode berikut.
uvicorn app:app --reloadDengan kode di atas, kita sudah memiliki API untuk menerima data dan membuat prediksi. Mari kita coba dengan kode berikut di terminal baru.
curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d "{\"tenure\": 72, \"InternetService\": \"Fiber optic\", \"OnlineSecurity\": \"Yes\", \"TechSupport\": \"Yes\", \"Contract\": \"Two year\", \"PaymentMethod\": \"Credit card (automatic)\"}"Output>>
{"prediction":0}Seperti yang Anda lihat, hasil API adalah sebuah dictionary dengan prediksi 0 (Not-Churn). Anda bisa menyesuaikan kodenya lebih lanjut untuk mendapatkan hasil yang diinginkan.
Selamat. Anda telah mengembangkan model machine learning Anda dan berhasil mendepoy modelnya dalam API.
Kesimpulan
Kita telah belajar bagaimana mengembangkan model machine learning dari awal hingga deployment. Lakukan eksperimen dengan dataset dan kasus lain untuk mendapatkan pemahaman yang lebih baik. Semua kode yang digunakan dalam artikel ini akan tersedia di repositori GitHub saya.
Comentários