1. Import Library¶

In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix

2. Memuat Dataset dari Hasil Clustering¶

In [ ]:
# Load dataset
df = pd.read_csv("dataset-label.csv")
In [3]:
df.head(2)
Out[3]:
Order_ID Customer_ID Customer_Type Product Category Unit_Price Quantity Discount Total_Price Region Order_Date Cluster_PCA
0 ORD100001 CUS1112 B2C Mango Juice Juices 3.12 1.0 0.0 3.12 Sachsen 2021-03-16 4
1 ORD1000934 CUS9934 B2B Cranberry Juice Juices 3.41 26.0 0.1 79.79 Nordrhein-Westfalen 2021-11-11 3
In [4]:
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 7551 entries, 0 to 7550
Data columns (total 12 columns):
 #   Column         Non-Null Count  Dtype  
---  ------         --------------  -----  
 0   Order_ID       7551 non-null   object 
 1   Customer_ID    7551 non-null   object 
 2   Customer_Type  7551 non-null   object 
 3   Product        7551 non-null   object 
 4   Category       7551 non-null   object 
 5   Unit_Price     7551 non-null   float64
 6   Quantity       7551 non-null   float64
 7   Discount       7551 non-null   float64
 8   Total_Price    7551 non-null   float64
 9   Region         7551 non-null   object 
 10  Order_Date     7551 non-null   object 
 11  Cluster_PCA    7551 non-null   int64  
dtypes: float64(4), int64(1), object(7)
memory usage: 708.0+ KB
In [5]:
# Drop kolom yang tidak diperlukan
df = df.drop(['Order_ID', 'Customer_ID', 'Order_Date'], axis=1)
In [6]:
# Memisahkan fitur dan target
X = df.drop('Cluster_PCA', axis=1)
y = df['Cluster_PCA']
In [7]:

3. Data Splitting¶

In [8]:
# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)
In [9]:
print("Shape of X_train:", X_train.shape)
print("Shape of X_test:", X_test.shape)
print("Shape of y_train:", y_train.shape)
print("Shape of y_test:", y_test.shape)

Shape of X_train: (6040, 8)
Shape of X_test: (1511, 8)
Shape of y_train: (6040,)
Shape of y_test: (1511,)

4. Membangun Model Klasifikasi¶

a. Membangun Model Klasifikasi¶

Pembangunan 3 model menggunakan Pipeline:

  1. Random Forest
  2. Logistic Regression
  3. Gradient Boosting
In [10]:
# Preprocessing
preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numerical_cols),
    ('cat', OneHotEncoder(drop='first', handle_unknown='ignore'), categorical_cols)
])

# Model
models = {
    'Random Forest': RandomForestClassifier(random_state=42),
    'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(random_state=42)
}

Tentang model:¶

Random Forest menggabungkan banyak pohon keputusan untuk membuat prediksi yang lebih akurat dan mengurangi risiko overfitting.

Logistic Regression lebih sederhana dan mudah dipahami, cocok untuk klasifikasi biner, tapi kurang efektif pada data yang sangat kompleks.

Sementara itu, Gradient Boosting membangun model secara bertahap, memperbaiki kesalahan dari model sebelumnya, dan memberikan hasil yang sangat baik pada data yang lebih rumit, meskipun memerlukan sedikit lebih banyak perhatian untuk menghindari overfitting.

Ketiga model ini akan dievaluasi berdasarkan akurasi, precision, recall, dan F1-Score untuk melihat mana yang paling efektif.

In [ ]:
# Build Model & Training
train_results = []
trained_models = {}
y_preds_test = {}

for model_name, model in models.items():
    pipeline = Pipeline(steps=[
        ('preprocessor', preprocessor),
        ('classifier', model)
    ])
    
    pipeline.fit(X_train, y_train)

    # Simpan pipeline dan prediksi untuk confusion matrix
    trained_models[model_name] = pipeline
    y_preds_test[model_name] = pipeline.predict(X_test)

    # Training
    y_pred_train = pipeline.predict(X_train)
    train_results.append({
        'Model': model_name,
        'Train Accuracy': accuracy_score(y_train, y_pred_train),
        'Train Precision': precision_score(y_train, y_pred_train, average='weighted', zero_division=0),
        'Train Recall': recall_score(y_train, y_pred_train, average='weighted', zero_division=0),
        'Train F1-Score': f1_score(y_train, y_pred_train, average='weighted', zero_division=0)
    })

# DataFrame hasil training
train_results_df = pd.DataFrame(train_results)
train_results_df
Out[ ]:
Model Train Accuracy Train Precision Train Recall Train F1-Score
0 Random Forest 1.0 1.0 1.0 1.0
1 Logistic Regression 1.0 1.0 1.0 1.0
2 Gradient Boosting 1.0 1.0 1.0 1.0

💡

Berdasarkan hasil model di atas, didapatkan nilai 100% untuk semua metrik. Hal ini mengindikasikan bahwa model mampu mengklasifikasikan data dengan sangat sempurna, tanpa kesalahan baik pada data training.

b. Evaluasi Model Klasifikasi¶

Hasil prediksi (evaluasi) untuk test set.

In [12]:
Out[12]:
Model Test Accuracy Test Precision Test Recall Test F1-Score
0 Random Forest 1.0 1.0 1.0 1.0
1 Logistic Regression 1.0 1.0 1.0 1.0
2 Gradient Boosting 1.0 1.0 1.0 1.0
In [13]:
# Confusion matrix
def plot_confusion_matrix(model_name):
    if model_name not in y_preds_test:
        print(f"Model '{model_name}' tidak ditemukan.")
        return
    y_pred = y_preds_test[model_name]
    cm = confusion_matrix(y_test, y_pred)
    plt.figure(figsize=(6, 4))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False)
    plt.title(f'Confusion Matrix - {model_name}')
    plt.xlabel('Predicted Label')
    plt.ylabel('True Label')
    plt.tight_layout()
    plt.show()
In [14]:
plot_confusion_matrix("Random Forest")
No description has been provided for this image
In [15]:
plot_confusion_matrix("Gradient Boosting")
No description has been provided for this image
In [16]:
plot_confusion_matrix("Logistic Regression")
No description has been provided for this image

💡

Berdasarkan hasil evaluasi terhadap test set, diperoleh akurasi dan F1-Score sebesar 100% untuk semua model. Hal ini menunjukkan bahwa model mampu mengklasifikasikan data dengan sangat baik tanpa kesalahan pada data uji.

c. Tuning Model Klasifikasi (Optional)¶

Gunakan GridSearchCV, RandomizedSearchCV, atau metode lainnya untuk mencari kombinasi hyperparameter terbaik

In [17]:
# Tidak dilakukan karena model sudah baik

d. Evaluasi Model Klasifikasi setelah Tuning (Optional)¶

Berikut adalah rekomendasi tahapannya.

  1. Gunakan model dengan hyperparameter terbaik.
  2. Hitung ulang metrik evaluasi untuk melihat apakah ada peningkatan performa.
In [18]:
# Tidak dilakukan karena model sudah baik

e. Analisis Hasil Evaluasi Model Klasifikasi¶

In [19]:
print("Hasil Training:")
train_results_df

Hasil Training:
Out[19]:
Model Train Accuracy Train Precision Train Recall Train F1-Score
0 Random Forest 1.0 1.0 1.0 1.0
1 Logistic Regression 1.0 1.0 1.0 1.0
2 Gradient Boosting 1.0 1.0 1.0 1.0
In [20]:
print("Hasil Testing:")
test_results_df

Hasil Testing:
Out[20]:
Model Test Accuracy Test Precision Test Recall Test F1-Score
0 Random Forest 1.0 1.0 1.0 1.0
1 Logistic Regression 1.0 1.0 1.0 1.0
2 Gradient Boosting 1.0 1.0 1.0 1.0

Hasil Evaluasi

Berdasarkan hasil evaluasi, ketiga model klasifikasi yaitu Random Forest, Logistic Regression, dan Gradient Boosting menunjukkan performa yang sangat tinggi, dengan nilai akurasi, precision, recall, dan F1-score mencapai 100% pada data training maupun testing. Hal ini menunjukkan bahwa model mampu mengklasifikasikan data tanpa kesalahan.

Identifikasi Kelemahan Model

  • Tidak ditemukan kelemahan metrik seperti precision atau recall yang rendah, karena seluruh metrik menunjukkan nilai sempurna.
  • Karena nilai akurasi training dan testing sama-sama 100%, model tidak menunjukkan indikasi overfitting maupun underfitting, tetapi perlu dilakukan validasi tambahan untuk memastikan hal tersebut.

Rekomendasi Tindakan Lanjutan

  • Lakukan validasi silang (cross-validation) untuk menguji kestabilan performa model di berbagai subset data.
  • Menguji model dengan data baru atau data dari distribusi berbeda untuk menguji kemampuan generalisasi.
  • Mencoba algoritma lain seperti XGBoost atau SVM untuk membandingkan performa, terutama jika model akan digunakan dalam skenario produksi nyata.