Python za analizu podataka: mašinsko učenje uz Scikit-Learn

Piše Yasin TANIŞ

Prvobitno objavljeno na Mediumu

Naslovna ilustracija o mašinskom učenju uz Scikit-Learn

Uvod

Mašinsko učenje je grana nauke koja računarima omogućava da uče iz podataka i prave predviđanja, i danas se koristi u mnogim privrednim granama. U ovom tekstu razmatramo Scikit-Learn, jednu od najkorišćenijih Python biblioteka za izradu aplikacija mašinskog učenja.

Šta je Scikit-Learn

Scikit-Learn je biblioteka za mašinsko učenje koja nudi jednostavne i efikasne alate za Python. Sadrži algoritme i za nadgledano i za nenadgledano učenje.

Instalacija

Prije početka biblioteku treba instalirati. Ako je još nemate na sistemu, instalirajte je ovom komandom:

pip install scikit-learn

Napomena: primjeri su namjerno jednostavni kako bi ilustrovali pojmove i nijesu uvijek najbolja mjera ili metoda za svaki scenario.

Nadgledano učenje

Nadgledano učenje radi s označenim podacima: ishodi (oznake) primjera su poznati, pa model može naučiti da ih predviđa.

Logistička regresija

Logistička regresija je široko korišćen algoritam za probleme klasifikacije.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Veri setini yükle
iris = load_iris()
X = iris.data
y = iris.target
# Veriyi eğitim ve test olarak ayır
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Model oluştur ve eğit
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)
# Tahmin yap ve doğruluğu ölç
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Model accuracy: {accuracy}')
Model Accuracy : 1.0

Ovaj kod učitava skup podataka Iris, dijeli ga na obilježja i ciljnu promjenljivu, obučava model i ispisuje njegovu tačnost.

Stabla odlučivanja

Stabla odlučivanja su moćan algoritam i za klasifikaciju i za regresiju.

from sklearn.tree import DecisionTreeClassifier

# Model oluştur ve eğit
tree_model = DecisionTreeClassifier(random_state=42)
tree_model.fit(X_train, y_train)

# Tahmin yap ve doğruluğu ölç
y_pred_tree = tree_model.predict(X_test)
accuracy_tree = accuracy_score(y_test, y_pred_tree)

print(f'Decision Tree Model accuracy: {accuracy_tree}')
Decision Tree Model Accuracy: 1.0

Nenadgledano učenje

Nenadgledano učenje ne koristi označene podatke; model pokušava da sam otkrije strukturu podataka.

Klasterovanje K-Means

K-Means je čest algoritam klasterovanja koji dijeli podatke na k klastera.

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Örnek veri seti oluştur
from sklearn.datasets import make_blobs
X, _ = make_blobs(n_samples=300, centers=4, random_state=42)

# Model oluştur ve eğit
kmeans = KMeans(n_clusters=4, random_state=42)
kmeans.fit(X)

# Tahmin yap ve kümeleri görselleştir
y_kmeans = kmeans.predict(X)

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75)
plt.title('K-Means Clustering')
plt.show()
Raspršeni grafikon s rezultatom klasterovanja K-Means
Izlaz koda: klasterovanje K-Means uz Scikit-Learn.

Analiza glavnih komponenti (PCA)

PCA je tehnika za svođenje višedimenzionalnih podataka na manji broj dimenzija.

from sklearn.decomposition import PCA

# Model oluştur ve eğit
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_kmeans, s=50, cmap='viridis')
plt.title('PCA Visualization')
plt.show()
Podaci Iris prikazani na prve dvije glavne komponente
Izlaz koda: PCA vizuelizacija uz Scikit-Learn.

Podešavanje hiperparametara

Podešavanje hiperparametara važan je korak da bi model dao najbolje rezultate. Klasa GridSearchCV iz Scikit-Learna to olakšava.

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

# Parametre uzayını tanımla
param_grid = {'C': [0.1, 1, 10], 'kernel': ['rbf', 'linear']}

# Grid search nesnesi oluştur
grid_search = GridSearchCV(SVC(), param_grid, cv=5)

# Grid search'ü uygula
grid_search.fit(X_train, y_train)

print("En iyi parametreler:", grid_search.best_params_)
print("En iyi skor:", grid_search.best_score_)
En iyi parametreler: {'C': 1, 'kernel': 'linear'}
En iyi skor: 0.9583333333333334

(Oznake u izlazu su na turskom jer ih izvorni kod tako ispisuje: „najbolji parametri“ i „najbolji rezultat“.)

Unakrsna validacija

Unakrsna validacija je važna tehnika za mjerenje koliko dobro model generalizuje na nove podatke.

import numpy as np

# Örnek sayısını en küçük olan veri setine eşitleyin
min_samples = min(X.shape[0], y.shape[0])

# Rastgele örnekleme yapın
np.random.seed(42)  # Tekrarlanabilirlik için
indices = np.random.choice(X.shape[0], min_samples, replace=False)
X = X[indices]
y = y[:min_samples]  # y zaten daha küçük

print("New X shape:", X.shape)
print("New y shape:", y.shape)
New X shape: (150, 2)
New y shape: (150,)
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

# Lojistik regresyon modelini oluştur
log_reg = LogisticRegression()

# 5-fold cross-validation uygula
scores = cross_val_score(log_reg, X, y, cv=5)
print("Cross-validation skorları:", scores)
print("Ortalama skor:", scores.mean())
Cross-validation skorları: [0.33333333 0.4 0.26666667 0.36666667 0.3 ]
Ortalama skor: 0.33333333333333337

Napomena o ispravci: niski rezultati ovdje potiču iz prethodnog koraka, a ne od modela. Kod za ponovno uzorkovanje nasumično miješa redove u X, ali oznake u y ne miješa na isti način, pa oznake više ne odgovaraju redovima i model pada na nivo slučajnosti (oko 0,33 kod tri klase). Ako se taj korak izostavi ili se X i y biraju istim indeksima, rezultati ponovo rastu. Metrike i rezultati pipeline-a u nastavku niski su iz istog razloga, jer koriste iste podatke.

Izbor i inženjering obilježja

Izbor i inženjering obilježja imaju ključnu ulogu u performansama modela. Scikit-Learn nudi alate koji olakšavaju te korake.

from sklearn.feature_selection import SelectKBest, f_classif

# En iyi 2 özelliği seç
selector = SelectKBest(f_classif, k=2)
X_new = selector.fit_transform(X, y)

print("Seçilen özellikler:", selector.get_support())
Seçilen özellikler: [ True True]

Tumačenje modela

Naročito kod modela kao što su stabla odlučivanja važno je razumjeti kako model donosi odluke.

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

# Karar ağacını görselleştir
plt.figure(figsize=(20,10))
plot_tree(tree_model, feature_names=iris.feature_names, class_names=iris.target_names, filled=True)
plt.show()
Dijagram stabla odlučivanja obučenog na skupu podataka Iris

Grafikon prikazuje stablo odlučivanja klasifikatora obučenog na skupu Iris. Stablo pomoću nekoliko pravila razdvaja klase setosa, versicolor i virginica:

  1. Korijenski čvor: uslov petal length ≤ 2,45 cm; Gini 0,667; 120 primjera, raspodjela [40, 41, 39]. Ovdje su klase najviše izmiješane.
  2. Lijevi čvor potomak: Gini 0,0; svih 40 primjera pripada klasi setosa. Jedno pravilo potpuno izdvaja setosu.
  3. Desni čvor potomak (petal length > 2,45 cm): Gini 0,5; 80 primjera, raspodjela [0, 41, 39]. Versicolor i virginica su i dalje izmiješane.
  4. Finija podjela: uslov petal length ≤ 4,75 cm; Gini 0,206; 43 primjera, raspodjela [0, 5, 38], većinom virginica.
  5. Niži čvorovi: uslov petal width ≤ 1,75 cm; Gini 0,0; svih 35 primjera pripada klasi virginica.

Svaki čvor prikazuje Gini koeficijent, broj primjera i raspodjelu klasa, pa se može tačno pratiti koje obilježje model koristi u kojoj tački i kako odlučuje.

Ansambl metode

Ansambl metode kombinuju više modela kako bi dale jača predviđanja. Random Forest je jedna od najpopularnijih.

from sklearn.ensemble import RandomForestClassifier

# Random Forest modeli oluştur ve eğit
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

# Tahmin yap ve doğruluğu ölç
y_pred_rf = rf_model.predict(X_test)
accuracy_rf = accuracy_score(y_test, y_pred_rf)

print(f'Random Forest Model accuracy: {accuracy_rf}')
Random Forest Model accuracy: 1.0

Metrike vrednovanja

Osim tačnosti, važne su i druge metrike vrednovanja.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix

# Veri setini ayır
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Modeli eğit
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)

# Tahminler yap
y_pred_log = log_reg.predict(X_test)

# Sınıflandırma raporu oluştur
print(classification_report(y_test, y_pred_log, target_names=iris.target_names))

# Confusion matrix oluştur
cm = confusion_matrix(y_test, y_pred_log)
print("Confusion Matrix:\n", cm)
Izlaz s izvještajem o klasifikaciji i matricom konfuzije
Izlaz koda: metrike klasifikacije.

Ovi rezultati pokazuju performanse modela obučenog na podacima izmiješanim u prethodnom koraku:

  • Preciznost (udio tačnih među pozitivnim predviđanjima): setosa 17%, versicolor 15%, virginica 37%.
  • Odziv (udio pronađenih stvarno pozitivnih primjera): setosa 5%, versicolor 23%, virginica 54%.
  • F1 mjera (harmonijska sredina preciznosti i odziva): setosa 0,08, versicolor 0,18, virginica 0,44.
  • Ukupna tačnost: 24%.
  • Makro prosjek: preciznost 23%, odziv 27%, F1 23%. Ponderisani prosjek: preciznost 22%, odziv 24%, F1 21%.

U matrici konfuzije 1 primjer setose predviđen je tačno, 12 kao versicolor i 6 kao virginica; kod klase versicolor 3 su tačna, 4 predviđena kao setosa i 6 kao virginica; kod klase virginica 7 je tačno, 1 kao setosa i 5 kao versicolor.

Tumačenje i prijedlozi

Ukupne performanse su niske; najbolje rezultate ima virginica, ali ni oni nijesu dovoljno dobri. Kao što objašnjava gornja napomena o ispravci, glavni uzrok su izmiješane oznake. Osim toga, ovi koraci uglavnom poboljšavaju performanse:

  • Isprobati jače modele kao što su Random Forest ili SVM i podesiti njihove hiperparametre
  • Dodati nova obilježja ili transformisati postojeća
  • Uravnotežiti klase metodama kao što je SMOTE ako su neuravnotežene
  • Koristiti unakrsnu validaciju da bi se uočilo preprilagođavanje (overfitting) ili nedovoljno prilagođavanje (underfitting)

Primjena u praksi: segmentacija kupaca

Kao primjenu u praksi uzmimo segmentaciju kupaca jedne kompanije za e-trgovinu.

from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# Örnek veri oluştur (gerçek senaryoda bu veri müşteri veritabanından gelir)
customer_data = np.random.rand(1000, 3)  # 1000 müşteri, 3 özellik (örn: yaş, toplam harcama, ziyaret sıklığı)

# Veriyi ölçeklendir
scaler = StandardScaler()
customer_data_scaled = scaler.fit_transform(customer_data)

# K-Means uygula
kmeans = KMeans(n_clusters=4, random_state=42)
clusters = kmeans.fit_predict(customer_data_scaled)

print("Müşteri segmentleri:", np.unique(clusters))
Müşteri segmentleri: [0 1 2 3]

Scikit-Learn pipeline

Pipeline ulančava korake predobrade i obuke modela, pa je kod pregledniji i efikasniji.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

# Pipeline oluştur
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression())
])

# Pipeline'ı eğit ve değerlendir
pipeline.fit(X_train, y_train)
accuracy_pipeline = pipeline.score(X_test, y_test)

print(f'Pipeline Model accuracy: {accuracy_pipeline}')
Pipeline Model accuracy: 0.24444444444444444

Studija slučaja: klasifikacija na skupu Iris

U ovoj studiji primjenjujemo više algoritama mašinskog učenja na skup Iris i poredimo rezultate.

Priprema podataka

Prvo učitavamo skup podataka i dijelimo ga na skup za obuku i skup za testiranje.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Veri setini yükle
iris = load_iris()
X = iris.data
y = iris.target

# Veriyi eğitim ve test olarak ayır
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Primjena i poređenje algoritama

Sada primjenjujemo logističku regresiju, stablo odlučivanja i KNN i poredimo njihove rezultate.

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Lojistik Regresyon
log_reg = LogisticRegression(max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_log = log_reg.predict(X_test)
accuracy_log = accuracy_score(y_test, y_pred_log)

# Karar Ağaçları
tree_model = DecisionTreeClassifier(random_state=42)
tree_model.fit(X_train, y_train)
y_pred_tree = tree_model.predict(X_test)
accuracy_tree = accuracy_score(y_test, y_pred_tree)

# KNN
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_test, y_pred_knn)

print(f'Logistic Regression accuracy: {accuracy_log}')
print(f'Decision Tree accuracy: {accuracy_tree}')
print(f'KNN accuracy: {accuracy_knn}')
Logistic Regression accuracy: 1.0
Decision Tree accuracy: 1.0
KNN accuracy: 1.0

Zaključak

U ovom tekstu prošli smo kroz faze procesa mašinskog učenja uz Scikit-Learn i vidjeli kako se one primjenjuju. Nadgledane i nenadgledane algoritme primijenili smo na skup Iris, a pored osnovnih algoritama obradili smo optimizaciju, vrednovanje i tumačenje, primjenu u praksi i pipeline. Zahvaljujući širokom skupu alata, Scikit-Learn naučnicima za podatke i praktičarima mašinskog učenja olakšava rješavanje složenih problema.

Izvori

  1. Pedregosa, F. i dr. (2011). Scikit-learn: Machine Learning in Python. Journal of Machine Learning Research, 12, 2825–2830.
  2. Dokumentacija Scikit-Learna: scikit-learn.org
  3. Hastie, T., Tibshirani, R. i Friedman, J. (2009). The Elements of Statistical Learning. Springer.
  4. Kuhn, M. i Johnson, K. (2013). Applied Predictive Modeling. Springer.
  5. Géron, A. (2019). Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow. O’Reilly Media.
  6. Müller, A. C. i Guido, S. (2016). Introduction to Machine Learning with Python. O’Reilly Media.
  7. Raschka, S. i Mirjalili, V. (2019). Python Machine Learning. Packt Publishing.
  8. VanderPlas, J. (2016). Python Data Science Handbook. O’Reilly Media.