Python Tutorial (18): Machine Learning Dasar dengan scikit-learn

pip install scikit-learn pandas numpy matplotlib

1. Load & explore data
2. Preprocess (clean, encode, scale)
3. Split train/test
4. Train model
5. Evaluate
6. Predict on new data

from sklearn.datasets import load_iris
import pandas as pd
 
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df["target"] = iris.target
df["species"] = df["target"].map({0: "setosa", 1: "versicolor", 2: "virginica"})
 
print(df.head())
print(df["species"].value_counts())

from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
 
iris = load_iris()
X = iris.data          # features (input)
y = iris.target        # labels (output)
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,       # 20% untuk test
    random_state=42,     # reproducible
    stratify=y,          # proporsi kelas sama di train/test
)
 
print(f"Train: {X_train.shape}, Test: {X_test.shape}")

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
 
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42, stratify=iris.target
)
 
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
 
y_pred = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2%}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
 
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)
 
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X_train, y_train)
 
print(f"Accuracy: {accuracy_score(y_test, tree.predict(X_test)):.2%}")
 
# Feature importance
for name, importance in zip(iris.feature_names, tree.feature_importances_):
    print(f"{name}: {importance:.3f}")

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
import numpy as np
 
# Data sintetis: y = 2x + 1 + noise
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 2 * X.squeeze() + 1 + np.random.randn(100) * 2
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
model = LinearRegression()
model.fit(X_train, y_train)
 
y_pred = model.predict(X_test)
print(f"Coefficients: {model.coef_[0]:.2f}")
print(f"Intercept: {model.intercept_:.2f}")
print(f"R² Score: {r2_score(y_test, y_pred):.3f}")
print(f"RMSE: {mean_squared_error(y_test, y_pred)**0.5:.3f}")

from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
 
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)
 
# Pipeline: scale → train (hindari data leakage)
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("knn", KNeighborsClassifier(n_neighbors=5)),
])
 
pipeline.fit(X_train, y_train)
print(f"Accuracy: {pipeline.score(X_test, y_test):.2%}")

from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
 
iris = load_iris()
model = KNeighborsClassifier(n_neighbors=5)
 
scores = cross_val_score(model, iris.data, iris.target, cv=5)
print(f"CV Scores: {scores}")
print(f"Mean: {scores.mean():.2%} (+/- {scores.std() * 2:.2%})")

from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    confusion_matrix,
)
 
# y_test, y_pred dari model sebelumnya
print(confusion_matrix(y_test, y_pred))
print(f"Precision: {precision_score(y_test, y_pred, average='weighted'):.2f}")
print(f"Recall: {recall_score(y_test, y_pred, average='weighted'):.2f}")
print(f"F1: {f1_score(y_test, y_pred, average='weighted'):.2f}")

from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
 
iris = load_iris()
 
param_grid = {
    "n_neighbors": [3, 5, 7, 9, 11],
    "weights": ["uniform", "distance"],
    "metric": ["euclidean", "manhattan"],
}
 
grid = GridSearchCV(
    KNeighborsClassifier(),
    param_grid,
    cv=5,
    scoring="accuracy",
)
grid.fit(iris.data, iris.target)
 
print(f"Best params: {grid.best_params_}")
print(f"Best score: {grid.best_score_:.2%}")

import joblib
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
 
iris = load_iris()
model = KNeighborsClassifier(n_neighbors=5)
model.fit(iris.data, iris.target)
 
# Save
joblib.dump(model, "iris_knn_model.joblib")
 
# Load
loaded = joblib.load("iris_knn_model.joblib")
prediction = loaded.predict([[5.1, 3.5, 1.4, 0.2]])
print(f"Predicted class: {prediction[0]}")