1.

Soal Klasifikasi Sloan Digital Sky Survey DR14

1. Pengumpulan dan Pemrosesan Data:

Proses membersihkan data:
1. Memuat Dataset: Data dimuat ke dalam DataFrame `df_sky` dari file CSV.
2. Menampilkan Informasi Awal: Informasi awal tentang DataFrame ditampilkan,
termasuk nama-nama kolom (`columns`), beberapa baris data pertama (`head`), bentuk
DataFrame (`shape`), dan informasi tipe data (`info`).
3. Menghapus Spasi dari Nama Kolom: Jika ada spasi di awal atau akhir nama kolom,
spasi tersebut dihapus menggunakan `.str.strip()`.
4. Mengatasi Nilai yang Hilang: Menghapus baris yang mengandung nilai kosong
(`NaN`) menggunakan `.dropna()`.
5. Normalisasi atau Standarisasi Fitur: Hanya kolom-kolom numerik yang akan
dinormalisasi menggunakan `StandardScaler` dari `sklearn.preprocessing`.
6. Pemilihan Variabel Target: Mendefinisikan variabel target (`y`) yang ingin diprediksi
(dalam hal ini, kolom `'class'`).
7. Opsional: Memisahkan Data Train dan Test: Memisahkan data menjadi data latih (`train
set`) dan data uji (`test set`) menggunakan `train_test_split` dari
`sklearn.model_selection`.

import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Memuat dataset
df_sky = pd.read_csv('/content/Skyserver_SQL2_27_2018 6_51_39
PM.csv')

# Menampilkan informasi awal dataset

print("Informasi awal dataset:")
print(df_sky.columns)
print(df_sky.head())
print(df_sky.shape)
df_sky.info()
 # Menghapus spasi dari nama kolom (jika ada)
df_sky.columns = df_sky.columns.str.strip()

# Mengatasi nilai yang hilang (NaN)

df_sky.dropna(inplace=True)

# Normalisasi atau standarisasi fitur (khusus untuk kolom

numerik)
scaler = StandardScaler()
numerical_columns = df_sky.select_dtypes(include=['float64',
'int64']).columns # Memilih kolom numerik
X = df_sky[numerical_columns] # Memilih hanya kolom-kolom
numerik sebagai fitur
X_scaled = scaler.fit_transform(X) # Menormalisasi fitur-fitur
numerik

# Mendefinisikan variabel target

y = df_sky['class'] # Menggunakan kolom 'class' sebagai
variabel target

# Memisahkan data menjadi train set dan test set (opsional)

X_train, X_test, y_train, y_test = train_test_split(X_scaled,
y, test_size=0.2, random_state=42)

Output yang dihasilkan dari perintah diatas ialah berupa informasi data yaitu variabel yang
ada didalamnya dan juga mengetahui isi data tersebut ada sebanyak 10000 baris dan 18
kolom. Berikut hasil yang dapat ditampilkan.

Informasi awal dataset:

Index(['objid', 'ra', 'dec', 'u', 'g', 'r', 'i', 'z',
'run', 'rerun', 'camcol',
'field', 'specobjid', 'class', 'redshift', 'plate',
'mjd', 'fiberid'],
dtype='object')
objid ra dec u g
r i \
0 1.237650e+18 183.531326 0.089693 19.47406 17.04240
15.94699 15.50342
1 1.237650e+18 183.598370 0.135285 18.66280 17.21449
16.67637 16.48922
2 1.237650e+18 183.680207 0.126185 19.38298 18.19169
17.47428 17.08732
3 1.237650e+18 183.870529 0.049911 17.76536 16.60272
16.16116 15.98233
4 1.237650e+18 183.883288 0.102557 17.55025 16.26342
16.43869 16.55492

z run rerun camcol field specobjid class

redshift plate \
0 15.22531 752 301 4 267 3.722360e+18 STAR -
0.000009 3306
1 16.39150 752 301 4 267 3.638140e+17 STAR -
0.000055 323
2 16.80125 752 301 4 268 3.232740e+17 GALAXY
0.123111 287
3 15.90438 752 301 4 269 3.722370e+18 STAR -
0.000111 3306
4 16.61326 752 301 4 269 3.722370e+18 STAR
0.000590 3306

mjd fiberid
0 54922 491
1 51615 541
2 52023 513
3 54922 510
4 54922 512
(10000, 18)
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10000 entries, 0 to 9999
Data columns (total 18 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 objid 10000 non-null float64
1 ra 10000 non-null float64
2 dec 10000 non-null float64
3 u 10000 non-null float64
4 g 10000 non-null float64
5 r 10000 non-null float64
6 i 10000 non-null float64
7 z 10000 non-null float64
8 run 10000 non-null int64
9 rerun 10000 non-null int64
10 camcol 10000 non-null int64
11 field 10000 non-null int64
12 specobjid 10000 non-null float64
13 class 10000 non-null object
14 redshift 10000 non-null float64
15 plate 10000 non-null int64
16 mjd 10000 non-null int64
17 fiberid 10000 non-null int64
dtypes: float64(10), int64(7), object(1)
memory usage: 1.4+ MB
2. Pembagian Data:
Berapa persentase data yang akan Anda gunakan untuk pelatihan dan pengujian? 80% data
untuk pelatihan, 20% data untuk pengujian
Mengapa Anda memilih pembagian tersebut? Karena dengan menggunakan sebagian
besar data untuk pelatihan (80%) model akan memiliki kesempatan yang lebih besar
agar model yang dihasilkan akan baik. Dan dengan menggunakan data pengujian
20% memungkinkan untuk dapat menguji performa model yang tidak pernah di
lihat sebelumnya.

Kita dapat menggunakan data menjadi data training dan data testing dengan perintah yang
digunakan sebagai berikut.

from sklearn.model_selection import train_test_split

# Memisahkan fitur dan target

X = df_sky.drop('class', axis=1)
y = df_sky['class']

# Pembagian data untuk pelatihan dan pengujian

X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)

Hasil data training untuk variabel X sebanyak 8000 baris karena data train yang digunakan
80% dari 10000 data, dengan jumlah kolom sebanyak 17. Dan untuk data testing sebanyak
2000 baris karena data test yang digunakan sebesar 20%.
3. Pemilihan Model:
Model klasifikasi apa yang akan Anda pertimbangkan untuk tugas ini dan mengapa?
Sebutkan setidaknya dua model dan berikan alasan pemilihan Anda. Model klasifikasi
yang digunakan ialah Random Forest Classifier menggunakan model ini karena
efektif dalam menangani banyak fitur,dapat meminimalkan overfitting, dan dapat
memberikan pentingnya fitur. Model kedua yang dapat digunakan ialah Support
Vector Machine (SVM) yang cocok digunakan untuk menyelesaikan klasifikasi
dengan banyak fitur dengan data yang kompleks.
Kita dapat menggunakan perintah memanggil kedua model yang akan digunakan dengan
memanggil library yang ada pada pyton seperti berikut.

from sklearn.ensemble import RandomForestClassifier

from sklearn.svm import SVC
 # Inisialisasi model
rf_model = RandomForestClassifier()
svm_model = SVC()

4. Pelatihan dan Evaluasi Model:

Bagaimana Anda akan mengevaluasi kinerja model Anda? Jelaskan metrik yang akan
digunakan dan mengapa metrik tersebut penting. Kita dapa mengevaluasi kinerja model
dengan menggunakan metrik seperti akurasi, presisi, recall, dan f1-score.
Metrik-metrik ini sangat penting untuk mengetahui seberapa baik model
mengklasifikasikan setiap objek langit dan mengidentifikasi kinerja mdel secara
keseluruhan.
Kita dapat melihat akurasi dari model random forsest dan juga svm sebagai berikut.

from sklearn.metrics import accuracy_score, classification_report

# Pelatihan dan evaluasi model Random Forest

rf_model.fit(X_train, y_train)
y_pred_rf = rf_model.predict(X_test)
print("Accuracy Random Forest:", accuracy_score(y_test,
y_pred_rf))
print(classification_report(y_test, y_pred_rf))

# Pelatihan dan evaluasi model SVM

svm_model.fit(X_train, y_train)
y_pred_svm = svm_model.predict(X_test)
print("Accuracy SVM:", accuracy_score(y_test, y_pred_svm))
print(classification_report(y_test, y_pred_svm))

Accuracy Random Forest: 0.9895

precision recall f1-score support

GALAXY 0.99 0.99 0.99 996

QSO 0.97 0.95 0.96 190
STAR 0.99 1.00 1.00 814

accuracy 0.99 2000

macro avg 0.99 0.98 0.98 2000
weighted avg 0.99 0.99 0.99 2000

Accuracy SVM: 0.7815

precision recall f1-score support

GALAXY 0.72 0.98 0.83 996

 QSO 0.00 0.00 0.00 190
STAR 0.91 0.72 0.80 814

accuracy 0.78 2000

macro avg 0.54 0.57 0.54 2000
weighted avg 0.73 0.78 0.74 2000

Akurasi dengan menggunakan random forest 0.9895 dan menggunakan svm sebesar
0.7815 selisih akurasi model yang didapat sebesar 0.208 saja artinya tidak begitu banyak
perbedaan yang signifikan antar kedua model.

5. Optimasi Model atau Hyperparameter Tuning:

Proses Optimasi model atau hyperparameter tuning sangat berguna untuk meningkatkan
performa model dengan menyesuaikan parameter (semisal anda menggunakan Grid Search
atau Random Search) Bagaimana teknik ini dapat membantu Anda dalam menemukan
parameter terbaik untuk model Anda? Dengan menggunakan teknik Grid Search atau
Random Search ini dapat membantu kita untuk menemukan kombinasi parameter
terbaik untuk model yang dibuat. Hal ini membantu kita dalam meningkatkan
performa model dengan menyesuaikan parameter-parameter yang optimal.

Kita dapat menggunakan library/packages gridseacrch untuk melihat seberapa besar

parameter yang dihasilkan dari model ialah sebagai berikut.

import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler

# Memuat dataset
df_sky = pd.read_csv('/content/Skyserver_SQL2_27_2018 6_51_39
PM.csv')

# Menghapus spasi dari nama kolom (jika ada)

df_sky.columns = df_sky.columns.str.strip()

# Mengatasi nilai yang hilang (NaN)

df_sky.dropna(inplace=True)
# Memisahkan data menjadi fitur (X) dan target (y)
X = df_sky.drop('class', axis=1) # Semua kolom kecuali 'class'
sebagai fitur
y = df_sky['class'] # Kolom 'class' sebagai target

# Normalisasi fitur (opsional)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Memisahkan data menjadi train set dan test set

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y,
test_size=0.2, random_state=42)

# Inisialisasi model RandomForestClassifier

rf = RandomForestClassifier()

# Definisikan grid parameter yang akan diuji

param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [None, 10, 20],
'min_samples_split': [2, 5, 10]
}

# Inisialisasi Grid Search dengan cross-validation (CV=5)

grid_search = GridSearchCV(estimator=rf, param_grid=param_grid,
cv=5, scoring='accuracy', verbose=2, n_jobs=-1)

# Melatih model dengan Grid Search untuk menemukan parameter

terbaik
grid_search.fit(X_train, y_train)

# Menampilkan parameter terbaik dan skor akurasi terbaik

print("Best Parameters:", grid_search.best_params_)
print("Best Cross-Validation Score (Accuracy):",
grid_search.best_score_)

# Evaluasi model terbaik pada data test

best_rf = grid_search.best_estimator_
test_accuracy = best_rf.score(X_test, y_test)
print("Test Accuracy of Best Model:", test_accuracy)
 Fitting 5 folds for each of 27 candidates, totalling 135 fits
Best Parameters: {'max_depth': None, 'min_samples_split': 2,
'n_estimators': 200}
Best Cross-Validation Score (Accuracy): 0.988875
Test Accuracy of Best Model: 0.9895

Dengan menggunakan k=5 memiliki akurasi yang cukup besar yaitu 0.98875 atau 98%
akurat.

6. Implementasi Cross-Validation:
Mengapa langkah k-fold cross-validation perlu dimasukkan dalam prosedur? Jelaskan
pentingnya k-fold cross-validation dalam konteks pembuatan model klasifikasi ini.
K-fold cross-validation ini penting untuk menghindari terjadi overfitting pada data
dan memastikan generalisasi model tersebut ialah model yang baik. Model akan
dinilai dengan k-fold cross-validation untuk menguji performa pada multiple subset
data.

Kita dapat menggunakan library/packages cross_val_score untuk melihat akurasi nilai

validasi dengan random forest untuk melihat score cross-validation dan nilai rata-rata dari
akurasi cross-validation dari model random forest.

from sklearn.model_selection import cross_val_score

# Cross-validation untuk Random Forest

cv_scores_rf = cross_val_score(rf_model, X_train, y_train, cv=5)
print("Cross-Validation Scores for Random Forest:", cv_scores_rf)
print("Mean CV Accuracy for Random Forest:", cv_scores_rf.mean())

Cross-Validation Scores for Random Forest: [0.99125 0.984375

0.988125 0.985625 0.991875]
Mean CV Accuracy for Random Forest: 0.9882500000000001

from sklearn.svm import SVC

from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification

# Contoh pembuatan dataset untuk cross-validation

 X, y = make_classification(n_samples=100, n_features=17,
random_state=42)

# Inisialisasi model SVM

svm_model = SVC(kernel='rbf', C=1.0, gamma='scale',
random_state=42)

# Cross-validation untuk SVM

cv_scores_svm = cross_val_score(svm_model, X, y, cv=5)

# Menampilkan skor cross-validation untuk SVM

print("Cross-Validation Scores for SVM:", cv_scores_svm)
print("Mean CV Accuracy for SVM:", cv_scores_svm.mean())

Cross-Validation Scores for SVM: [0.95 0.95 0.95 0.95 1. ]

Mean CV Accuracy for SVM: 0.96

Dengan menggunakan svm dan cv=5 juga memiliki akurasi yang cukup besar yaitu 0.95
atau 95% akurat.

7. Prediksi dan Interpretasi:

Jika diberikan sebuah pengamatan baru dengan 17 fitur (silahkan buat 1 data baru),
jelaskan langkah-langkah yang akan Anda ambil untuk menggunakan model yang telah
dilatih untuk mengklasifikasikan pengamatan tersebut. Bagaimana Anda akan
menginterpretasikan output dari model? Gunakan model yang telah dilatih untuk
melakukan prediksi terhadap data baru. Setelah melakukan prediksi, hasil klasifikasi
akan menjadi label kategori objek langit berdasarkan fitur-fitur yang diberikan.
Hasil prediksi dari model akan memberikan informasi klasifikasi tentang kategori
objek langit yang dapat diinterpretasikan berdasarkan label atau output kelas yang
diprediksi.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# Contoh pembuatan dan pelatihan model Random Forest

X, y = make_classification(n_samples=100, n_features=17,
random_state=42)
 # Contoh data untuk pelatihan
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)

rf_model = RandomForestClassifier(n_estimators=100,
max_depth=None, min_samples_split=2, random_state=42)
rf_model.fit(X_train, y_train)

# 7. prediksi untuk pengamatan baru

new_observation = [[0.5, 18.3, 15.2, 0.8, 0.6, 19.1, 35.2, 17.7,
0.15, 0.25, 15.5, 0.8, 1.2, 0.9, 10.5, 1.0, 11.8]]

# Melakukan prediksi menggunakan model terlatih (best_rf)

predicted_class = rf_model.predict(new_observation)

# Mengecek kelas hasil prediksi

if predicted_class == 0:
print("Predicted Class: Star")
elif predicted_class == 1:
print("Predicted Class: Galaxy")
else:
print("Predicted Class: Quasar")

Predicted Class: Galaxy

2. Soal Klasifikasi Kualitas Red Wine

1. Pengumpulan Data:
Jelaskan Langkah langkah yang perlu Anda ambil untuk mengakses data ini.
Pertama buka link https://www.kaggle.com/datasets/uciml/red-wine-quality-cortez-et-al-
2009/data , kemudian unduh data dengan klik download.
Setelah data berhasil di unduh, dapat di import data tersebut kedalam phyton.
Lalu, panggil nama data yang berhasil di import untuk melihat struktur datanya,
menggunakan perintah berikut.

#1
# Import library yang dibutuhkan
import pandas as pd

# Load dataset
file_path = '/content/winequality-red.csv'
data = pd.read_csv(file_path)

# Tampilkan informasi dataset

print(data.head()) # Melihat 5 baris pertama data
print(data.info()) # Informasi tentang dataset

Data wine diatas berisi 1958 baris dan 12 kolom dengan rincian variabel dalam kolom
sebagai berikut.

fixed acidity volatile acidity citric acid residual sugar

chlorides \
0 7.4 0.70 0.00 1.9
0.076
1 7.8 0.88 0.00 2.6
0.098
2 7.8 0.76 0.04 2.3
0.092
3 11.2 0.28 0.56 1.9
0.075
4 7.4 0.70 0.00 1.9
0.076

free sulfur dioxide total sulfur dioxide density pH

sulphates \
0 11.0 34.0 0.9978 3.51
0.56
1 25.0 67.0 0.9968 3.20
0.68
2 15.0 54.0 0.9970 3.26
0.65
3 17.0 60.0 0.9980 3.16
0.58
4 11.0 34.0 0.9978 3.51
0.56

alcohol quality
0 9.4 5
1 9.8 5
 2 9.8 5
3 9.8 6
4 9.4 5
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1599 entries, 0 to 1598
Data columns (total 12 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 fixed acidity 1599 non-null float64
1 volatile acidity 1599 non-null float64
2 citric acid 1599 non-null float64
3 residual sugar 1599 non-null float64
4 chlorides 1599 non-null float64
5 free sulfur dioxide 1599 non-null float64
6 total sulfur dioxide 1599 non-null float64
7 density 1599 non-null float64
8 pH 1599 non-null float64
9 sulphates 1599 non-null float64
10 alcohol 1599 non-null float64
11 quality 1599 non-null int64
dtypes: float64(11), int64(1)
memory usage: 150.0 KB
None

2. Pemrosesan Data Awal:

- Apa langkah pertama yang harus Anda lakukan setelah mendapatkan dataset? Langkah
awal setelah mendapatkan dataset ialah melihat jumlah data dan melihat apakah
terdapat data yang hilang(NULL)
Bagaimana Anda akan menangani nilai yang hilang atau outlier dalam dataset ini?
Jika terdapat data yang hilang kita dapat mengisi data tersebut menggunakan nilai
rata-rata dari data untuk mengisi data yang hilang atau outlier.
- Mengapa penting untuk melakukan normalisasi atau standarisasi pada fitur dalam dataset?
Serta pembagian data training dan testing? Jelaskan prosedurnya.
Dengan melakukan normalisasi/standarisasi akan membantu menghindari masalah
skala yang berbeda, dan meningkatkan kinerja logaritma untuk mencegah masalah
numerik.

Proses pembagian data training digunakan untuk melatih model, sementara data
testing digunakan untuk menguji seberapa baik model tersebut dapat melakukan
prediksi pada data yang belum pernah dilihat sebelumnya. Dengan memisahkan data
pengujian, kita dapat menghindari overfitting, yaitu kondisi di mana model terlalu
"menghafal" data pelatihan dan gagal generalisasi dengan baik pada data baru.
Dengan menggunakan data pengujian yang tidak pernah dilihat selama pelatihan,
kita dapat memastikan bahwa model dapat melakukan prediksi dengan baik pada
data baru.
Prosedur pembagian data training dan testing:
- Pertama, data harus dibagi menjadi dua bagian: training set dan testing set. Pembagian
umum adalah sekitar 80% untuk training dan 20% untuk testing, tetapi ini dapat
bervariasi tergantung pada ukuran dataset dan kebutuhan spesifik.
- Kedua, terapkan normalisasi atau standarisasi pada fitur-fitur dalam dataset. Ini
biasanya dilakukan setelah pembagian data, agar tidak ada kebocoran informasi dari
data pengujian ke data pelatihan.
- Setelah itu, Gunakan training set yang telah dinormalisasi atau distandarisasi untuk
melatih model. Setelah model dilatih, gunakan testing set yang telah dinormalisasi atau
distandarisasi untuk menguji kinerja model. Evaluasi model menggunakan metrik-
metrik seperti akurasi, presisi, recall, dan lainnya untuk menilai seberapa baik model
dapat melakukan prediksi pada data baru.

#2
# Mengatasi nilai yang hilang
data.fillna(data.mean(), inplace=True) # Mengganti nilai hilang
dengan nilai rata-rata

# Mengatasi outlier (misal menggunakan teknik IQR)

Q1 = data.quantile(0.25)
Q3 = data.quantile(0.75)
IQR = Q3 - Q1
data = data[~((data < (Q1 - 1.5 * IQR)) | (data > (Q3 + 1.5 *
IQR))).any(axis=1)]

3. Pemilihan Model:
- Sebutkan dan jelaskan minimal dua model klasifikasi yang cocok untuk tugas ini.
Mengapa model-model ini cocok untuk klasifikasi kualitas wine? Model klasifikasi yang
dapat kita gunakan ialah klasifikasi random forest, DecisionTreeClassifier dan
Logistic Regression. Dimana model model ini dapat menangani data dengan banyak
fitur (seperti data kualitas wine yang mungkin memiliki banyak atribut kimia). Tidak
sensitif terhadap skewness atau distribusi data, sehingga cocok untuk data yang
beragam seperti pada kualitas wine. Memiliki kemampuan untuk menangani
overfitting, yang berguna dalam memodelkan variasi kompleksitas kualitas wine
berdasarkan atribut kimia. Cocok untuk data dengan representasi numerik yang
beragam, seperti atribut kimia pada kualitas wine. Mudah diinterpretasikan, karena
memberikan nilai probabilitas untuk kelas tertentu.
Efisien dalam menangani masalah klasifikasi biner (misalnya, memprediksi apakah
kualitas wine baik atau buruk).

#3
# Import library untuk model
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Memisahkan fitur dan target

X = data.drop('quality', axis=1)
y = data['quality'] > 6 # kategori baik atau tidak

# Pembagian data training dan testing

X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)

# Inisialisasi dan pelatihan model Logistic Regression

logreg_model = LogisticRegression()
logreg_model.fit(X_train, y_train)

# Inisialisasi dan pelatihan model Random Forest Classifier

rf_model = RandomForestClassifier()
rf_model.fit(X_train, y_train)

# Inisialisasi dan pelatihan model Decision Tree Classifier

dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)

4. Pembagian Data dengan k-fold Cross-Validation:

- Apa itu k-fold cross-validation dan bagaimana Anda akan mengimplementasikannya
dalam konteks dataset ini? K-fold Cross-Validation adalah salah satu teknik validasi
silang yang umum digunakan untuk mengukur kinerja model secara lebih akurat
dan mengurangi bias serta variasi dalam estimasi kinerja model. Teknik ini
melibatkan pembagian dataset menjadi k subset yang lebih kecil (biasanya k = 5 atau
10), di mana setiap subset akan digunakan sebagai set validasi (testing) satu kali,
sementara subset lainnya digunakan sebagai data pelatihan (training).

Pertama, kita akan membagi dataset menjadi k subset yang lebih kecil. Misalnya,
jika kita menggunakan k = 5, maka dataset akan dibagi menjadi 5 bagian (folds).
Untuk setiap iterasi, salah satu dari k subset akan digunakan sebagai set validasi
(testing), sedangkan k-1 subset lainnya digunakan sebagai data pelatihan (training).
Ini berarti kita akan melakukan pelatihan dan evaluasi model sebanyak k kali, di
mana setiap subset akan menjadi set validasi sekali. Setelah model dilatih pada k-1
subset, kita akan mengukur kinerja model dengan menggunakan subset yang
digunakan sebagai set validasi. Kinerja model (misalnya, akurasi) dari setiap iterasi
akan direkam. Setelah semua iterasi selesai, kita dapat menghitung rata-rata dari
kinerja model (misalnya, rata-rata akurasi) sebagai estimasi kinerja keseluruhan
model.

- Bagaimana k-fold cross-validation membantu mengurangi risiko overfitting dan

meningkatkan kemampuan generalisasi model? Dengan k-fold cross-validation, setiap
observasi dalam dataset akan digunakan untuk pelatihan dan validasi, sehingga
memaksimalkan penggunaan data dan menghasilkan model yang lebih robust dan
general.

from sklearn.model_selection import KFold

#4
# Import library untuk k-fold cross-validation
from sklearn.model_selection import cross_val_score, KFold

# Definisikan k-fold cross-validation

kf = KFold(n_splits=5, shuffle=True, random_state=42)

# Evaluasi model dengan k-fold cross-validation (contoh

menggunakan Random Forest)
 rf_cv_scores = cross_val_score(rf_model, X_train, y_train, cv=kf,
scoring='accuracy')

# Evaluasi model Logistic Regression dengan k-fold cross-

validation
logreg_cv_scores = cross_val_score(LogisticRegression(), X_train,
y_train, cv=kf, scoring='accuracy')

# Evaluasi model DecisionTreeClassifier dengan k-fold cross-

validation
dectree_cv_scores = cross_val_score(DecisionTreeClassifier(),
X_train, y_train, cv=kf, scoring='accuracy')

# Tampilkan hasil cross-validation

print("Random Forest Cross-validation scores (mean):",
rf_cv_scores.mean())
print("Logistic Regression Cross-validation scores (mean):",
logreg_cv_scores.mean())
print("DecisionTreeClassifier Cross-validation scores (mean):",
dectree_cv_scores.mean())

Hasil cross validation dari ketiga model ini memiliki hasil yang cukup berbeda yaitu untuk
rmodel random forest sebesar 91%, logistik regresi sebesar 89% dan decisiontree sebesar
86%.

Random Forest Cross-validation scores (mean): 0.9141055949566587

Logistic Regression Cross-validation scores (mean):

0.8982156928965439

DecisionTreeClassifier Cross-validation scores (mean):

0.8664246313182483

5. Pelatihan dan Evaluasi Model:

- Jelaskan langkah-langkah dalam pelatihan model menggunakan k-fold cross-validation.
Mulai dengan membagi dataset menjadi k subset (folds). Misalnya, jika kita memilih
k = 5, maka dataset akan dibagi menjadi 5 bagian yang sama besar. Lakukan iterasi
sebanyak k kali. Pada setiap iterasi, satu subset akan dijadikan sebagai set validasi
(testing), sementara k-1 subset lainnya digunakan sebagai data pelatihan (training).
Pada setiap iterasi, inisialisasikan model machine learning yang ingin digunakan
(misalnya, Random Forest, Logistic Regression, dll.). Selanjutnya, latih model
menggunakan data pelatihan, Setelah model dilatih pada data pelatihan, gunakan
model tersebut untuk melakukan prediksi pada subset validasi. Hitung metrik
evaluasi kinerja model yang dipilih (misalnya, akurasi, presisi, recall, F1-score)
menggunakan hasil prediksi dan label sebenarnya dari subset validasi.
- Apa metrik yang akan Anda gunakan untuk mengevaluasi kinerja model dan mengapa
metrik-metrik ini penting? Akurasi untuk mengukur sejauh mana model dapat
mengklasifikasikan dengan benar (tingkat keseluruhan kebenaran prediksi).
Presisi (Precision) untuk engukur proporsi positif yang benar dari semua hasil positif
yang diprediksi oleh model. Recall (Sensitivity) untuk mengukur proporsi positif
yang benar yang diidentifikasi oleh model dari semua kejadian positif yang
sebenarnya. F1-score sebagai kombinasi harmonik dari presisi dan recall. Berguna
ketika ingin mencari keseimbangan antara presisi dan recall.

#5
# Import library yang dibutuhkan
import numpy as np
import pandas as pd
from sklearn.model_selection import KFold, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score,
recall_score, f1_score
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
logreg_model = LogisticRegression(solver='liblinear') # Ganti
solver
# Inisialisasi model Logistic Regression dan Random Forest
Classifier
logreg_model = LogisticRegression()
rf_model = RandomForestClassifier()

# Definisikan k-fold cross-validation

k_fold = KFold(n_splits=5, shuffle=True, random_state=42)

# Fungsi untuk melakukan k-fold cross-validation dan menghitung

metrik evaluasi
 def evaluate_model(model, X, y, cv):
# Lakukan k-fold cross-validation
accuracy_scores = cross_val_score(model, X, y, cv=cv,
scoring='accuracy')
precision_scores = cross_val_score(model, X, y, cv=cv,
scoring='precision')
recall_scores = cross_val_score(model, X, y, cv=cv,
scoring='recall')
f1_scores = cross_val_score(model, X, y, cv=cv, scoring='f1')

# Tampilkan hasil evaluasi

print("Cross-validation scores:")
print(" Accuracy: {:.4f}".format(np.mean(accuracy_scores)))
print(" Precision: {:.4f}".format(np.mean(precision_scores)))
print(" Recall: {:.4f}".format(np.mean(recall_scores)))
print(" F1-score: {:.4f}".format(np.mean(f1_scores)))

# Evaluasi model Logistic Regression menggunakan k-fold cross-

validation
print("Evaluation for Logistic Regression:")
evaluate_model(logreg_model, X_train, y_train, k_fold)

# Evaluasi model Random Forest Classifier menggunakan k-fold

cross-validation
print("\nEvaluation for Random Forest Classifier:")
evaluate_model(rf_model, X_train, y_train, k_fold)

Evaluation for Logistict Regression Classifier:

Cross-validation scores:
Accuracy: 0.8982
Precision: 0.7500
Recall: 0.2065
F1-score: 0.3117

Evaluation for Random Forest Classifier:

Cross-validation scores:
Accuracy: 0.9109
Precision: 0.7300
Recall: 0.3543
F1-score: 0.4902

6. Optimasi Model atau Hyperparameter Tuning:

Proses Optimasi model atau hyperparameter tuning sangat berguna untuk meningkatkan
performa model dengan menyesuaikan parameter (semisal anda menggunakan Grid Search
atau Random Search) Bagaimana teknik ini dapat membantu Anda dalam menemukan
parameter terbaik untuk model Anda?
Dengan Grid Search, Anda dapat secara sistematis mencoba semua kombinasi dari
nilai parameter yang telah ditentukan, sedangkan dengan Randomized Search, Anda
secara acak memilih beberapa kombinasi nilai parameter untuk dievaluasi. Teknik
ini membantu Anda mengidentifikasi kombinasi parameter yang menghasilkan
kinerja terbaik untuk model Anda. Dengan menemukan parameter terbaik untuk
model Anda, Anda dapat meningkatkan kemampuan model untuk menggeneralisasi
pola pada data baru yang belum pernah dilihat sebelumnya. Ini menghasilkan model
yang lebih andal dan efektif dalam memprediksi pada data yang tidak digunakan
selama pelatihan. Proses optimasi parameter dapat membantu Anda menggunakan
sumber daya komputasi dengan lebih efisien.
#6
# Import library untuk optimasi model
from sklearn.model_selection import GridSearchCV

# Definisikan grid parameter

param_grid = {'n_estimators': [50, 100, 200],
'max_depth': [None, 10, 20]}

# Inisialisasi Grid Search untuk Random Forest Classifier

grid_search = GridSearchCV(RandomForestClassifier(), param_grid,
cv=3)
grid_search.fit(X_train, y_train)

# Parameter terbaik
print("Best parameters:", grid_search.best_params_)

Best parameters: {'max_depth': 20, 'n_estimators': 100}

7. Prediksi dan Interpretasi:

- Jelaskan proses yang akan Anda lakukan untuk menggunakan model yang telah dilatih
dalam membuat prediksi pada contoh data baru (silahkan buat satu data baru dengan
banyak variable sesuai dengan data)
Siapkan data baru dalam bentuk array atau DataFrame yang sesuai dengan format
yang digunakan oleh model saat pelatihan. Pastikan data baru memiliki jumlah
variabel (fitur) yang sama dengan data yang digunakan untuk melatih model. jika
model Anda melakukan normalisasi atau standarisasi pada data pelatihan, pastikan
untuk menerapkan transformasi yang sama pada data baru sebelum digunakan
untuk prediksi. Gunakan model yang telah dilatih untuk melakukan prediksi pada
data baru. Dalam kasus ini, kita akan menggunakan model Random Forest yang
telah dilatih sebelumnya.

- Bagaimana Anda akan menginterpretasikan hasil klasifikasi dari model? Apa implikasi
dari hasil klasifikasi tersebut terhadap penilaian kualitas wine?
Setelah melakukan prediksi, hasil klasifikasi akan menjadi nilai yang menunjukkan
kategori kualitas wine yang diprediksi untuk data baru. Jika model memberikan
prediksi kualitas wine yang tinggi (misalnya, label 1), ini mungkin mengindikasikan
bahwa wine memiliki karakteristik kimia yang sesuai dengan kualitas tinggi, seperti
keseimbangan rasa dan aroma yang baik. Sebaliknya, jika model memberikan
prediksi kualitas rendah (misalnya, label 0), ini mungkin menunjukkan adanya
kekurangan dalam atribut kimia yang diperlukan untuk kualitas yang lebih baik.

#7
import pandas as pd
from sklearn.ensemble import RandomForestClassifier

# Inisialisasi model RandomForestClassifier

rf_model = RandomForestClassifier()

# Latih (Fit) model dengan data training (X_train dan y_train)

rf_model.fit(X_train, y_train)

# Data baru yang ingin diprediksi

new_data = pd.DataFrame({
'fixed acidity': [8.0],
'volatile acidity': [0.6],
'citric acid': [0.25],
'residual sugar': [2.0],
 'chlorides': [0.08],
'free sulfur dioxide': [15.0],
'total sulfur dioxide': [50.0],
'density': [0.996],
'pH': [3.3],
'sulphates': [0.6],
'alcohol': [10.0]
})

# Prediksi kualitas wine pada data baru (new_data)

new_pred = rf_model.predict(new_data)

# Interpretasi hasil prediksi

if new_pred[0]:
print("Kualitas wine adalah baik (lebih dari 6).")
else:
print("Kualitas wine adalah tidak baik (kurang atau sama
dengan 6).")

Kualitas wine adalah tidak baik (kurang atau sama dengan 6).

3. Soal Market Basket Analysis untuk Transaction Data

1. Pengumpulan Data: Unduh dataset
2. Pemrosesan Data Awal:
Bersihkan data dari nilai yang hilang atau tidak konsisten. Agregat data berdasarkan
TransactionId untuk mendapatkan daftar barang per transaksi.

import pandas as pd

# Baca dataset
#Import data
data = pd.read_csv('/content/transaction_data.csv',
skiprows=[145190])
data.head()

#2
#Missing Value
data.isna().sum()
# Membersihkan data dari nilai yang hilang atau tidak konsisten
(jika perlu)
data.dropna(inplace=True) # Menghapus baris dengan nilai yang
hilang
data.info()

/usr/local/lib/python3.10/dist-
packages/ipykernel/ipkernel.py:283: DeprecationWarning:
`should_run_async` will not call `transform_cell` automatically
in the future. Please pass the result to `transformed_cell`
argument and any exception that happen during thetransform in
`preprocessing_exc_tuple` in IPython 7.17 and above.
and should_run_async(code)
<class 'pandas.core.frame.DataFrame'>
Index: 1080909 entries, 0 to 1083816
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 UserId 1080909 non-null int64
1 TransactionId 1080909 non-null int64
2 TransactionTime 1080909 non-null object
3 ItemCode 1080909 non-null int64
4 ItemDescription 1080909 non-null object
5 NumberOfItemsPurchased 1080909 non-null int64
6 CostPerItem 1080909 non-null float64
7 Country 1080909 non-null object
dtypes: float64(1), int64(4), object(3)
memory usage: 74.2+ MB

# mengubah menjadi data frame untuk Transaksi id

dataplus = data[(data['UserId'] >= 0) & (data['ItemCode'] >= 0) &
(data['NumberOfItemsPurchased'] >= 0)]
pd.DataFrame(data.groupby('TransactionId').nunique().sort_values('
ItemDescription',cending=False).head(10)['ItemDescription'])
 # Agregat data berdasarkan TransactionId untuk mendapatkan daftar
barang per transaksi
transaction_list = (dataplus[dataplus['Country']=="United
Kingdom"].groupby(['TransactionId','ItemDescription'])['NumberOfIt
emsPurchased']
.sum().unstack().reset_index().fillna(0).set_index(
'TransactionId'))
transaction_list

3. Mining Association Rules:

• Gunakan algoritma Apriori untuk menemukan itemset yang sering muncul.
• Hasilkan aturan asosiasi dari itemset tersebut dengan metrik seperti support,
confidence, dan lift.

#3
def encode_units(x):
 if x<=0:
return 0
if x>= 1:
return 1
transaction_list_plus = transaction_list.applymap(encode_units)
transaction_list_plus

#3 Encoding data transaksi menggunakan TransactionEncoder

transaction_filter_plus =
transaction_encode_plus[(transaction_encode_plus > 0).sum(axis=1)
>= 2]
transaction_filter_plus

#3 Terapkan algoritma Apriori untuk menemukan itemset yang sering

muncul
from mlxtend.frequent_patterns import apriori
frequent_itemsets_plus = apriori(transaction_filter_plus,
min_support=0.03,
use_colnames=True).sort_values('s
upport', ascending=False).reset_index(drop=True)

frequent_itemsets_plus['length'] =
frequent_itemsets_plus['itemsets'].apply(lambda x: len(x))

frequent_itemsets_plus

#3 asosiasi dari itemset tersebut dengan metrik seperti support,

confidence, dan lift.
from mlxtend.frequent_patterns import association_rules

association_rules(frequent_itemsets_plus, metric='lift',
min_threshold=1).sort_values('lift',
ascending=False).reset_index(drop=True)
4. Analisis dan Interpretasi Aturan:
• Identifikasi aturan dengan lift yang tinggi dan confidence yang tinggi sebagai
rekomendasi strategis.

#4
#lift yang tinggi dan confidence yang tinggi
rules = association_rules(frequent_itemsets_plus, metric="lift",
min_threshold=1)

# Mengidentifikasi aturan dengan lift tinggi dan confidence tinggi

rules[(rules['lift'] > 1) & (rules['confidence'] > 0.5)]

5. Strategi Pemasaran:
• Gunakan aturan yang diperoleh untuk menyarankan bundling produk atau
promosi cross-selling.
• Jika aturan mengatakan bahwa pelanggan yang membeli barang A juga
membeli barang B (misal, "Jika Bread maka juga Milk" dengan confidence
tinggi), gunakan ini untuk memposisikan barang secara strategis di toko atau
dalam promosi penjualan online.
• Hasil dari analisis juga bisa digunakan untuk mempromosikan barang2 yang
paling sering dibeli dengan diberikan diskon untuk menarik pembeli datang
ke toko tersebut.
• Gunakan strategi-strategi lainnya yang diperolah dari hasil analisis yang
didapatkan.

#5 menampilkan plot Strategi Pemasaran

import matplotlib.pyplot as plt

# Mendapatkan aturan asosiasi

rules = association_rules(frequent_itemsets_plus, metric='lift',
min_threshold=1)

# Memplot aturan asosiasi

plt.figure(figsize=(10, 6))
plt.scatter(rules['support'], rules['confidence'], alpha=0.5)
plt.xlabel('Support')
plt.ylabel('Confidence')
plt.title('Association Rules')
plt.show()

# Memplot aturan asosiasi dengan warna dan ukuran titik

berdasarkan lift
plt.figure(figsize=(10, 6))
plt.scatter(rules['support'], rules['confidence'],
c=rules['lift'], cmap='viridis', s=100*rules['lift'], alpha=0.5)
plt.colorbar(label='Lift')
rules['item_names'] = rules['antecedents'].apply(lambda x: ',
'.join(list(x)))
for i, txt in enumerate(rules['item_names']):
plt.annotate(txt, (rules['support'][i],
rules['confidence'][i]), fontsize=8, ha='center')
plt.xlabel('Support')
plt.ylabel('Confidence')
plt.title('Association Rules')
plt.show()
import matplotlib.pyplot as plt

# Mendapatkan aturan asosiasi

rules = association_rules(frequent_itemsets_plus, metric='lift',
min_threshold=1)

# Menambahkan nama item

rules['item_names'] = rules['antecedents'].apply(lambda x: ',
'.join(list(x)))

# Memplot aturan asosiasi dengan nama item

plt.figure(figsize=(12, 8))
plt.scatter(rules['support'], rules['confidence'], alpha=0.5)
for i, txt in enumerate(rules['item_names']):
plt.annotate(txt, (rules['support'][i],
rules['confidence'][i]), fontsize=8, ha='center')
plt.xlabel('Support')
plt.ylabel('Confidence')
plt.title('Association Rules')
plt.show()

Plot ini adalah scatter plot yang menggambarkan aturan asosiasi antara berbagai
produk.
 Sumbu Horizontal (Support): Sumbu ini menunjukkan dukungan (support) untuk
setiap aturan asosiasi. Nilai support menggambarkan seberapa sering aturan
tersebut terjadi dalam data transaksi. Nilai support diplot pada skala dari sekitar
0,7 hingga 0,4.
Sumbu Vertikal (Confidence): Sumbu ini menunjukkan tingkat kepercayaan
(confidence) untuk setiap aturan asosiasi. Confidence menggambarkan sejauh
mana item konsekuensi (consequents) cenderung dibeli jika item antecedents-
nya juga dibeli. Nilai confidence diplot pada skala dari sekitar 0,03 hingga 0,033.
Ukuran Bola: Ukuran setiap bola (bubble) mencerminkan nilai Lift, yang
mengukur hubungan antara item antecedents dan consequents. Semakin besar
bola, semakin kuat hubungannya.
Bola dengan item “JUMBO BAG RED RETROSPOT” dan “LUNCH BAG RED
RETROSPOT” memiliki nilai Lift tertinggi, menunjukkan bahwa kedua item ini
sering dibeli bersamaan dengan tingkat kepercayaan yang tinggi.
Item “GREEN REGENCY TEACUP AND SAUCER” juga memiliki Lift yang
tinggi dengan beberapa item lain.
Kesimpulan: Plot ini membantu kita memahami aturan asosiasi dalam data transaksi dan
dapat digunakan untuk strategi pemasaran atau manajemen stok.
#5
import matplotlib.pyplot as plt
import seaborn as sns

# Membuat pivot table untuk menampilkan korelasi antara item

pivot_table = rules.pivot(index='antecedents',
columns='consequents', values='lift')

# Plot heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(pivot_table, annot=True, cmap='inferno', fmt=".2f",
cbar=True)
plt.title('Association Rules')
plt.xlabel('Consequents')
plt.ylabel('Antecedents')
plt.show()
Plot ini adalah heatmap yang menggambarkan hubungan antara item-item dalam
analisis keranjang belanja.

Sumbu Vertikal (Lift): Sumbu ini menunjukkan nilai Lift, yang mengukur
seberapa kuat hubungan antara dua item. Lift menggambarkan sejauh mana item-
item tersebut cenderung dibeli bersamaan. Nilai Lift diplot pada skala dari sekitar
6.60 hingga 7.70.
Sumbu Horizontal (Consequents): Sumbu ini berisi daftar item-item seperti
“JUMBO BAG RED RETROSPOT”, “LUNCH BAG RED RETROSPOT”, dan
lainnya. Setiap kotak berwarna mewakili aturan asosiasi antara item-item ini.
Warna Kotak: Intensitas warna kotak mencerminkan kekuatan aturan asosiasi.
Semakin gelap warnanya, semakin kuat hubungannya.
 Kotak dengan item “JUMBO BAG RED RETROSPOT” dan “LUNCH BAG
RED RETROSPOT” memiliki nilai Lift tertinggi, menunjukkan bahwa kedua
item ini sering dibeli bersamaan.
Item “GREEN REGENCY TEACUP AND SAUCER” juga memiliki Lift yang
tinggi dengan beberapa item lain.
Kesimpulan: Plot ini membantu kita memahami keterkaitan antara item-item dalam
keranjang belanja dan dapat digunakan untuk strategi pemasaran atau rekomendasi
produk.