Nauč se Python > Kurzy > Datový kurz PyLadies > Strojové učení, klasifikace > Úvod klasifikace

Klasifikace #

Zatím jsme se zabývali jen regresními úlohami. Učení s učitelem ale zahrnuje dvě hlavní skupiny úloh - regresní úlohy a klasifikační úlohy.

Zatímco u regresních úloh je výstupem modelu spojitá hodnota (float), v klasifikačních úlohách představuje výstup modelu indikátor třídy (label).

Držme se našeho rybího trhu a ukažme si to na příkladu. Úloha predikovat váhu ryby byla regresní úloha, predikovali jsme spojitou hodnotu. Pokud budeme chtít predikovat druh ryby (Perch - okoun, Roach - plotice, Pike - štika, ...), jedná se o predikci kategorické hodnoty, tedy o klasifikaci.

Klasifikační úlohy mají trochu jiné vlastnosti a logiku, než úlohy regresní, proto existují modely přímo určené na takové úlohy. Říká se jim klasifikátory.

Zkusíme se ale nejdřív podívat na úlohu klasifikace z pohledu, který už známe, tedy z pohledu krajiny.

data

In [1]:
# načeteme si data 
import pandas as pd 
import numpy as np 
np.random.seed(2020)  # nastavení náhodného klasifikátoru

data = pd.read_csv("static/fish_data.csv", index_col=0)
data
Out[1]:
Species Weight Length1 Length2 Length3 Height Width ID
0 Bream 242.0 23.2 25.4 30.0 11.5200 4.0200 0
1 Bream 290.0 24.0 26.3 31.2 12.4800 4.3056 1
2 Bream 340.0 23.9 26.5 31.1 12.3778 4.6961 2
3 Bream 363.0 26.3 29.0 33.5 12.7300 4.4555 3
4 Bream 430.0 26.5 29.0 34.0 12.4440 5.1340 4
... ... ... ... ... ... ... ... ...
153 Smelt 9.8 11.4 12.0 13.2 2.2044 1.1484 153
154 Smelt 12.2 11.5 12.2 13.4 2.0904 1.3936 154
155 Smelt 13.4 11.7 12.4 13.5 2.4300 1.2690 155
156 Smelt 12.2 12.1 13.0 13.8 2.2770 1.2558 156
158 Smelt 19.9 13.8 15.0 16.2 2.9322 1.8792 158

123 rows × 8 columns

Úkol 1: #

Nejčastějším druhem ryby je Perch (okoun). Naším cílem je vytvořit klasifikátor, který pro zadané míry (váha, různé délky a šířky) vrátí informaci, zda se jedná o okouna nebo jiný druh. (Máme tedy pro jednoduchost jen dvě třídy, Perch a ostatní.)

  • Uměla bys tuto úlohu napasovat na krajinu? Co by mohly být souřadnice a co nadmořská výška?

  • Pokud ses úspěšně poprala s předchozím dotazem, můžeš na klasifikaci použít některý z regresních modelů (ano, asi to nebude ideální, když jde o klasifikaci, ale zkusme nejdříve to, co již umíme). Co ale bude hodnota odezvy a jak ji budeme interpretovat?

Klasifikační modely #

Přinášíme opět nějakou základní nabídku klasifikačních modelů:

Úkol 2: #

Vyberete si jeden model a zkuste natrénovat na ryby.

In [2]:
# připravme data
y = data["Species"] == "Perch"
y = y.astype(int)
X = data.drop(columns=["ID", "Species"])
In [3]:
# rozdělme na trénovací a validační množinu
from sklearn.model_selection import train_test_split 
X_train_raw, X_test_raw, y_train, y_test =  train_test_split(X, y, stratify=y)
In [4]:
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train_raw)
X_test = scaler.transform(X_test_raw)
In [5]:
# vezměme klasifikátor 
# můžeš změnit 
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
In [ ]:
# natrénujte
model.fit(X_train, y_train)
In [7]:
# ohodnoťme validační množinu 
pred = model.predict(X_test) 
In [8]:
print("Skutečná třída:  Predikce:")
for true, predicted in zip(y_test, pred):
    print(f"{true:<15}  {predicted:<10} {'OK' if true == predicted else 'X'}")

print(f"Počet chyb: {sum(y_test != pred)}")
Skutečná třída:  Predikce:
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
1                1          OK
0                0          OK
1                1          OK
0                0          OK
0                0          OK
1                0          X
0                0          OK
1                0          X
0                0          OK
1                0          X
0                0          OK
0                0          OK
0                0          OK
1                1          OK
0                0          OK
0                1          X
0                1          X
0                0          OK
0                0          OK
1                1          OK
1                0          X
1                1          OK
1                1          OK
1                1          OK
0                0          OK
Počet chyb: 6

Úkol 3: #

  • Asi je jasné, že regresní metriky se nám na klasifikační úlohy moc nehodí. Co bys použila jako metriku pro klasifikační úlohu?

Úkol 4: #

  • Jedna z možností je porovnávat procento úspěšně klasifikovaných vzorů. V našem případě, to bude:
In [9]:
print(f"Úspěšnost: {100*sum(y_test == pred)/len(y_test):.2f} %")
Úspěšnost: 80.65 %

Úspěšnost není úplně špatná, poznat druh ryby podle rozměrů není jendoduchá úloha.

Představ si ale, že budeme mít v datovou množinu se 100 rybami, 95 z nich bude okounů (typu Perch). Bude ti klasifikátor, který bude mít toto procento úspěšnosti (stejné jako vyšlo nám), připadat dobrý nebo ne? Proč?

Úkol 5: #

Nejprve projdeme klasifikační metriky. Pokud studuješ sama, nastuduj si kapitolu o klasifikačních metrikách a pak se vrať k tomuto cvičení.

Vyber si metriku pro naši úlohu a zkus najít, co nejlepší klasifikátor. Pak si načti testovací množinu a podívej se, jaké tvůj klasifikátor dává výsledky.

In [10]:
# zkus naučit různé modely a vyber nejlepší
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier 
from sklearn.svm import SVC
from sklearn.metrics import confusion_matrix

# zkus naučit různé modely a vyber nejlepší
models = {}

# KNeigbors 
for N in 1, 3, 5, 7:
    models[("nearest neighbors", N)] = KNeighborsClassifier(n_neighbors=N, weights="distance")
    
# tree
for d in range(3, 20):
    models[("tree", d)] = DecisionTreeClassifier(max_depth=d, class_weight='balanced')
    
# random forest
for N in range(1, 100):
    models[("random forest", N)] = RandomForestClassifier(n_estimators=N, class_weight='balanced')
    
# SVC
for C in range(-2, 10):
    models[("SVC", 10**C)] = SVC(C=10**C, class_weight='balanced')
In [11]:
from sklearn.metrics import f1_score

def train_and_eval(X_train, X_test, y_train, y_test, model):
    model.fit(X_train, y_train)
    y_pred_test = model.predict(X_test)
    y_pred_train = model.predict(X_train)
    return {"train": f1_score(y_train, y_pred_train), # metriku můžeš vyměnit za nějakou svojí
            "test": f1_score(y_test, y_pred_test)
           }
In [12]:
results = []
for name, model in models.items():
    res = train_and_eval(X_train, X_test, y_train, y_test, model)
    res["model"] = name[0]
    res["param"] = name[1]
    results.append(res)
    
df_results = pd.DataFrame(results)
df_results
Out[12]:
train test model param
0 1.000000 0.818182 nearest neighbors 1.000000e+00
1 1.000000 0.818182 nearest neighbors 3.000000e+00
2 1.000000 0.869565 nearest neighbors 5.000000e+00
3 1.000000 0.818182 nearest neighbors 7.000000e+00
4 0.704545 0.666667 tree 3.000000e+00
... ... ... ... ...
127 1.000000 1.000000 SVC 1.000000e+05
128 1.000000 1.000000 SVC 1.000000e+06
129 1.000000 1.000000 SVC 1.000000e+07
130 1.000000 1.000000 SVC 1.000000e+08
131 1.000000 1.000000 SVC 1.000000e+09

132 rows × 4 columns

In [13]:
import seaborn as sns
import matplotlib.pyplot as plt

def zobraz_model(model_name, ax, logx=False):
    sns.lineplot(x="param", y="train", data=df_results[df_results["model"]==model_name], label="train", ax=ax)
    sns.lineplot(x="param", y="test", data=df_results[df_results["model"]==model_name], label="test", ax=ax)
    ax.set_title(model_name.capitalize())
    if logx:
        ax.set(xscale="log")
    
fig, axs = plt.subplots(ncols=4, figsize=(16,4))
zobraz_model("nearest neighbors", axs[0])
zobraz_model("tree", axs[1])
zobraz_model("random forest", axs[2])
zobraz_model("SVC", axs[3], logx=True)
In [14]:
# načtení data
test_data = pd.read_csv("static/fish_data_test.csv", index_col=0)
y_real_test = test_data["Species"] == "Perch"
y_real_test = y_real_test.astype(int)
X_real_test = test_data.drop(columns=["ID", "Species"])
X_real_test = scaler.transform(X_real_test)
In [15]:
# predikce
model = models[("SVC", 10**4)]
test_pred = model.predict(X_real_test)
In [16]:
# zkus přidat zvolenou metriku
print(f"Skutečná třída:  Predikce:")
for true, predicted in zip(y_real_test, test_pred):
    print(f"{true:<15}  {predicted:<10} {'OK' if true == predicted else 'X'}")

print(f"Počet chyb: {sum(y_real_test != test_pred)}")
print(f"Úspěšnost: {100*sum(y_real_test == test_pred)/len(y_real_test):.2f} %")
Skutečná třída:  Predikce:
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                1          X
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
0                0          OK
1                0          X
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
1                1          OK
0                0          OK
0                0          OK
0                1          X
Počet chyb: 3
Úspěšnost: 91.67 %

Toto je stránka lekce z kurzu, který probíhá nebo proběhl naživo s instruktorem.