Langkah-langkah klasifikasi dengan mannequin Ok Nearest Neighbor (KNN)
1. Pengumpulan Information
Information yang digunakan merupakan dataset kualitas purple wine yang berasal dari kaggle dengan hyperlink https://www.kaggle.com/datasets/uciml/red-wine-quality-cortez-et-al-2009/data langkah awal yang dapat dilakukan adalah menginpor knowledge.
import pandas as pd
# load dataset
wine = pd.read_csv("/content material/sample_data/winequality-red.csv")
wine
2. Pemrosesan Information Awal
Setelah mengimpor dataset maka langkah berikutnya adalah bersihkan terlebih dahulu knowledge dari nilai yang hilang atau tidak konsisten. Bersihkan juga knowledge yang outlier dengan cara menghilangkan knowledge tersebut.
wine=wine.dropna()
wine.data()
import matplotlib.pyplot as plt# Visualisasi outlier dengan field plot
plt.determine(figsize=(12, 6))
wine.boxplot()
plt.title('Field plot untuk setiap fitur dalam DataFrame wine')
plt.xticks(rotation=45)
plt.present()
# Fungsi untuk menghapus outlier berdasarkan IQR
def remove_outliers(df, columns):
for col in columns:
Q1 = df[col].quantile(0.25)
Q3 = df[col].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
df = df[(df[col] >= lower_bound) & (df[col] <= upper_bound)]
return df# Daftar kolom yang ingin dihapus outlier-nya
columns = wine.columns
# Hapus outlier dari DataFrame wine
wine_no_outliers = remove_outliers(wine, columns)
# Jumlah baris sebelum dan setelah penghapusan outlier
print("Jumlah baris sebelum menghapus outlier:", len(wine))
print("Jumlah baris setelah menghapus outlier:", len(wine_no_outliers))
datawine=wine_no_outliers
datawine
Berikutnya, kita lakukan pengkodean. Pada variabel goal kita dapat melakukan mengklasifikasikan kualitas wine menjadi dua kategori baik (lebih dari 6), dan tidak baik. kategori baik menggunakan kode ‘1’ dan kategori kurang baik dengan kode ‘0’.
feature_cols = ['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides',
'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH','sulphates','alcohol']
X = datawine[feature_cols] # Options
y = (datawine['quality'] > 6).astype(int) # Goal variable
Kemudian, kita lakukan normalisasi fitur pada dataset. Hal tersebut dilakukan agar memiliki skala yang sama dalam fitur, menghindari prediksi yang bias. Sehingga, jika normalisasi dilakukan mannequin akan bekerja dengan baik dan menghasilkan prediksi yang lebih akurat.
# Normalization
scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X)
Selanjutnya, knowledge dibagi menjadi 70:30 dimana 70% adalah knowledge prepare dan 30% adalah knowledge testing. Alasan memilih pembagian ini adalah knowledge yang digunakan untuk melatih mannequin (coaching) harus lebih banyak daripada knowledge yang digunakan untuk menguji mannequin (testing) karena mannequin harus memiliki cukup informasi untuk belajar dan menyimpulkan pola dari knowledge.
X_train, X_test, y_train, y_test = train_test_split(X_normalized, y, test_size=0.3, random_state=4)# print the shapes of the brand new X objects
print(X_train.form)
print(X_test.form)
# print the shapes of the brand new X objects
print(y_train.form)
print(y_test.form)
3. pemilihan mannequin
Seperti yang sudah disebutkan diawal, kita akan menggunakan mannequin Ok nearst neighbor (KNN). Alasan menggunakan mannequin ini yaitu karena mannequin KNN mudah diterapkan, mudah beradaptasi saat sampel coaching baru ditambahkan, dan memiliki sedikit hyperparameter.
#Ok=5
from sklearn import metrics
from sklearn.neighbors import KNeighborsClassifierok=5
knn = KNeighborsClassifier(n_neighbors=5)
knn.match(X_train, y_train)
y_pred = knn.predict(X_test)
print(metrics.accuracy_score(y_test, y_pred))
ok=1
knn = KNeighborsClassifier(n_neighbors=1)
knn.match(X_train, y_train)
y_pred = knn.predict(X_test)
print(metrics.accuracy_score(y_test, y_pred))
# strive Ok=1 by Ok=25 and document testing accuracy
k_range = vary(1, 26)# We will create Python dictionary utilizing [] or dict()
scores = []
# We use a loop by the vary 1 to 26
# We append the scores within the dictionary
for ok in k_range:
knn = KNeighborsClassifier(n_neighbors=ok)
knn.match(X_train, y_train)
y_pred = knn.predict(X_test)
scores.append(metrics.accuracy_score(y_test, y_pred))
print(scores)
max(scores)
# import Matplotlib (scientific plotting library)
import matplotlib.pyplot as plt# enable plots to seem throughout the pocket book
%matplotlib inline
# plot the connection between Ok and testing accuracy
# plt.plot(x_axis, y_axis)
plt.plot(k_range, scores)
plt.xlabel('Worth of Ok for KNN')
plt.ylabel('Testing Accuracy')
Sumbu X (Worth of Ok for KNN) menunjukan nilai Ok yang digunakan dalam mannequin KNN. Setiap titik pada sumbu X mewakili satu nilai Ok yang diuji. Sedangkan suumbu Y (Testing Accuracy) menunjukan akurasi pengujian dari mannequin KNN yang dilatih dengan nilai Ok yang sesuai. Setiap titik pada sumbu Y mewakili akurasi pengujian untuk nilai Ok yang sesuai pada sumbu X. Grafik tersebut menunjukkan pola hubungan antara nilai Ok dan akurasi pengujian. Sehingga kita dapat mengetahui nilai Ok yang menghasilkan akurasi yang tinggi.
4. Pembagian Information dengan k-fold Cross-Validation
Pembagian knowledge dengan Ok-fold cross-validation adalah teknik umum yang digunakan dalam evaluasi kinerja mannequin machine studying. Dalam hal ini knowledge dibagi menjadi Ok bagian ( fold) yang sama besar, di mana salah satu fold digunakan sebagai knowledge uji dan sisanya digunakan sebagai knowledge pelatihan. Dalam studi kasus ini, pembagian knowledge dilakukan secara inside dengan menggunakan parameter ‘cv=10’ atau 10 fold yang artinya dataset akan dibagi menjadi 10 subset yang sama ukurannya.
Proses ini diulangi Ok kali dengan setiap fold digunakan sebagai knowledge uji secara bergantian. Ok-fold cross-validation membantu mengurangi risiko overfitting dan meningkatkan kemampuan generalisasi mannequin KNN dengan cara deteksi overfitting, evaluasi pada knowledge yang tak terlihat dan pemilihan parameter yang optimum. Dengan demikian, k-fold cross-validation membantu memastikan bahwa mannequin KNN memiliki kemampuan generalisasi yang baik dan tidak terlalu mempelajari detail-detail kecil dari knowledge latih yang mungkin tidak relevan dengan knowledge yang tidak terlihat. Hal ini membantu dalam menciptakan mannequin yang lebih umum dan dapat digunakan secara efektif pada knowledge baru.
5. Pelatihan dan Evaluasi Mannequin
Pelatihan mannequin dengan menggunakan Ok-fold cross-validation dengan 10 fold. Kemudian, untuk mengevaluasi kinerja mannequin kita dapat menggunakan akurasi yaitu matriks evaluasi yang paling umum digunakan. Matriks ini dilakukan dengan cara mengukur seberapa sering mannequin klasifikasi membuat prediksi yang benar dari whole prediksi yang dilakukan. Matriks ini sangat penting karena kita dapat mengetahui seberapa baik mannequin bekerja dalam memprediksi knowledge baru.
# imports
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
%matplotlib inline
print('X matrix dimensionality:', X.form)
print('Y vector dimensionality:', y.form)
# imports
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
%matplotlib inline
# 10-fold (cv=10) cross-validation with Ok=5 (n_neighbors=5) for KNN (the n_neighbors parameter)# instantiate mannequin
knn = KNeighborsClassifier(n_neighbors=5)
# retailer scores in scores object
# scoring metric used right here is 'accuracy' as a result of it is a classification drawback
# cross_val_score takes care of splitting X and y into the ten folds that is why we cross X and y fully as a substitute of X_train and y_train
scores = cross_val_score(knn, X_normalized, y, cv=10, scoring='accuracy')
print(scores)
# use common accuracy as an estimate of out-of-sample accuracy# scores is a numpy array so we will use the imply technique
print(scores.imply())
# seek for an optimum worth of Ok for KNN# record of integers 1 to 30
# integers we wish to strive
k_range = vary(1, 31)
# record of scores from k_range
k_scores = []
# 1. we are going to loop by affordable values of ok
for ok in k_range:
# 2. run KNeighborsClassifier with ok neighbours
knn = KNeighborsClassifier(n_neighbors=ok)
# 3. acquire cross_val_score for KNeighborsClassifier with ok neighbours
scores = cross_val_score(knn, X, y, cv=10, scoring='accuracy')
# 4. append imply of scores for ok neighbors to k_scores record
k_scores.append(scores.imply())
print(k_scores)
# plot the worth of Ok for KNN (x-axis) versus the cross-validated accuracy (y-axis)
plt.plot(k_range, k_scores)
plt.xlabel('Worth of Ok for KNN')
plt.ylabel('Cross-Validated Accuracy')
Sumbu X menunjukan nilai Ok untuk mannequin KNN, sedangkan sumbu Y menunjukan akurasi yang disesuaikan dengan validasi silang (cross-validated accuracy)
6. Optimasi Mannequin atau Hyperparameter Tuning
Dalam optimasi mannequin kita menggunakan random search. Random search merupakan salah satu metode optimasi hyperparameter yang sering digunakan. Random search akan bekerja dengan cara mencoba setiap kombinasi parameter secara acak. Sehingga, random search dapat lebih efisien.
from sklearn.model_selection import RandomizedSearchCV, KFold
from sklearn.neighbors import KNeighborsClassifier
from scipy.stats import randint
from sklearn.preprocessing import MinMaxScaler# Outline the dataset
feature_cols = ['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar', 'chlorides',
'free sulfur dioxide', 'total sulfur dioxide', 'density', 'pH','sulphates','alcohol']
X = datawine[feature_cols]
y = (datawine['quality'] > 6).astype(int)
# Normalization
scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X)
# Mannequin yang akan dioptimasi
mannequin = KNeighborsClassifier()
# Daftar parameter yang akan diuji
param_dist = {
'n_neighbors': randint(1, 30), # rentang nilai untuk n_neighbors
}
# Inisialisasi RandomizedSearchCV dengan k-fold cross-validation
kf = KFold(n_splits=5)
random_search = RandomizedSearchCV(mannequin, param_distributions=param_dist, n_iter=10, cv=kf)
# Lakukan pencarian
random_search.match(X_normalized, y)
# Tampilkan parameter terbaik dan skor terbaik
print("Greatest Parameters:", random_search.best_params_)
print("Greatest Rating:", random_search.best_score_)
Diperoleh parameter terbaik atau jumlah tetangga (n_neighbors) dalam rentang 1 hingga 30 adalah 28 dengan skor terbaik yang dicapai sebesar 0,8941.
Optimasi ini membantu untuk menemukan kombinasi hyperparameter yang optimum dan dapat menghindari overfitting pada knowledge pelatihan.
7. Prediksi dan Interpretasi
Langkah terakhir dalam klasifikasi kualitas purple wine adalah memprediksi knowledge baru dengan menggunakan parameter terbaik yang telah ditemukan yaitu 28.
# instantiate the mannequin with one of the best recognized parameters
knn = KNeighborsClassifier(n_neighbors=28)# prepare the mannequin with X and y (not X_train and y_train)
knn.match(X_normalized, y)
# make a prediction for an out-of-sample commentary
prediction=knn.predict([[7.5,0.52,0.16,1.9,0.085,12,35,0.9968,3.38,0.62,9.5]])
print("predicted class :", prediction)
# instantiate the mannequin with one of the best recognized parameters
knn = KNeighborsClassifier(n_neighbors=28)# prepare the mannequin with X and y (not X_train and y_train)
knn.match(X_normalized, y)
# make a prediction for an out-of-sample commentary
prediction=knn.predict([[7.9, 0.35, 0.46, 3.6, 0.078, 15, 37, 0.9973, 3.35, 0.86, 12.8]])
print("predicted class :", prediction)
Output diatas menunjukkan bahwa hasil prediksi dari kedua knowledge baru diprediksi sebagai kategori 0 (kualitas baik) dan 1 (kurang baik). Hal ini menunjukan bahwa mannequin klasifikasi telah menentukan bahwa knowledge yang diberikan memiliki karakteristik yang sesuai dengan kategori 0 dan 1.
