A gépi tanulás (machine learning) a mesterséges intelligencia azon ága, amely adatokból automatikusan tanul mintákat, és ezeket ismeretlen esetekre általánosítja. A Python ökoszisztémájában a scikit-learn könyvtár a klasszikus ML algoritmusok legkiterjedtebb és legjobban dokumentált gyűjteménye. Emellett a NumPy és Pandas elengedhetetlen eszközök az adatok előkészítéséhez.

A scikit-learn gépi tanulás könyvtár logója

A scikit-learn könyvtár logója (forrás: Wikimedia Commons, BSD licenc)

Felügyelt és felügyelet nélküli tanulás

A gépi tanulás feladatait két fő kategóriába szokás sorolni:

  • Felügyelt tanulás (supervised learning): A modell feliratozott adatokon tanul — vagyis minden bemeneti mintához adott a helyes kimenet. Tipikus feladatok: osztályozás (pl. spam-szűrés), regresszió (pl. ingatlanár-becslés).
  • Felügyelet nélküli tanulás (unsupervised learning): Nincsenek előre megadott feliratok; a modell maga keres struktúrát az adatban. Tipikus feladatok: klaszterezés (pl. vásárlói szegmentálás), dimenziócsökkentés (PCA).

Adatbetöltés és -elemzés Pandasszal

A Pandas könyvtár DataFrame struktúrája a táblázatos adatok kezelésének de facto eszköze Python-ban. Lehetővé teszi CSV, Excel és egyéb formátumú adatok betöltését, szűrését és átalakítását.

import pandas as pd

df = pd.read_csv('adatok.csv')

print(df.shape)       # Sorok és oszlopok száma
print(df.dtypes)      # Oszloptípusok
print(df.isnull().sum())  # Hiányzó értékek száma

# Leíró statisztikák
print(df.describe())

# Szűrés
nagy_arak = df[df['ar'] > 50_000_000]
print(nagy_arak.head())

Adatelőkészítés

A gépi tanulási modellek érzékenyek az adatok skálájára és formátumára. A leggyakoribb előkészítési lépések:

  • Hiányzó értékek kezelése: Kitöltés az oszlop átlagával, mediánjával, vagy az adott sor törlése.
  • Kategorikus változók kódolása: One-hot encoding vagy sorszámozás numerikus reprezentációhoz.
  • Skálázás: StandardScaler (z-score normalizáció) vagy MinMaxScaler alkalmazása, hogy a különböző skálájú jellemzők ne torzítsák a modellt.
  • Tanuló/teszt szétválasztás: Az adatot jellemzően 80/20 arányban osztják tanuló- és teszthalmazra.
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np

X = df.drop('celvaltozo', axis=1).values
y = df['celvaltozo'].values

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

skalezo = StandardScaler()
X_train = skalezo.fit_transform(X_train)
X_test  = skalezo.transform(X_test)

Osztályozási algoritmusok scikit-learn-nel

A scikit-learn egységes API-t biztosít: minden modell fit(), predict() és score() metódusokkal rendelkezik. Ez megkönnyíti az algoritmusok összehasonlítását.

from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# Véletlenerdő modell
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
print("Véletlenerdő pontosság:", accuracy_score(y_test, y_pred_rf))

# Logisztikus regresszió
lr = LogisticRegression(max_iter=200)
lr.fit(X_train, y_train)
y_pred_lr = lr.predict(X_test)
print("Logisztikus regresszió pontosság:", accuracy_score(y_test, y_pred_lr))

print(classification_report(y_test, y_pred_rf))

Regresszió: folytonos értékek előrejelzése

Ha a cél egy folytonos numerikus érték előrejelzése (pl. lakásár, hőmérséklet, forgalom), regressziós modelleket alkalmazunk. A kiértékelés nem pontossággal, hanem hibamértékekkel (MAE, RMSE) történik.

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_absolute_error, root_mean_squared_error

gbr = GradientBoostingRegressor(n_estimators=200, learning_rate=0.05)
gbr.fit(X_train, y_train)
y_pred = gbr.predict(X_test)

print("MAE:", mean_absolute_error(y_test, y_pred))
print("RMSE:", root_mean_squared_error(y_test, y_pred))

Keresztvalidáció

Az egyszerű tanuló/teszt szétválasztás esetén a modell teljesítménye függ attól, éppen hogyan kerültek az adatok a halmazokba. A keresztvalidáció (k-fold cross-validation) ezt a bizonytalanságot csökkenti azzal, hogy az adatot k részre osztja, és k-szor tanítja be/értékeli a modellt.

from sklearn.model_selection import cross_val_score

pontossagok = cross_val_score(
    RandomForestClassifier(n_estimators=100, random_state=42),
    X, y,
    cv=5,
    scoring='accuracy'
)

print("Átlagos pontosság:", pontossagok.mean().round(4))
print("Szórás:", pontossagok.std().round(4))

Pipeline a gépi tanulásban

A scikit-learn Pipeline objektuma lehetővé teszi az adatelőkészítési és modellezési lépések összefűzését egyetlen egységbe. Ez megakadályozza az adatszivárgást (data leakage) és leegyszerűsíti a kód karbantarthatóságát.

from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('skalezo', StandardScaler()),
    ('modell', RandomForestClassifier(n_estimators=100))
])

pipeline.fit(X_train, y_train)
print("Pipeline pontosság:", pipeline.score(X_test, y_test))

Klaszterezés felügyelet nélkül

Ha nincsenek feliratok, a K-Means algoritmus k darab klaszterre osztja az adatot az euklidészi távolság minimalizálásával. A k értékét tipikusan az „elbow method" vagy a silhouette-együttható segítségével választják meg.

from sklearn.cluster import KMeans

klaszter = KMeans(n_clusters=3, random_state=42, n_init=10)
klaszter.fit(X_train)
cimkek = klaszter.labels_
print("Klasztercímkék:", cimkek[:10])

Hivatkozások