Klasifikace

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

def read_fish_data(filename):
    return (
        pd.read_csv(filename, index_col=0)
        .rename(columns={
            "Species": "druh",
            "Weight": "vaha",
            "Length1": "delka1",
            "Length2": "delka2",
            "Length3": "delka3",
            "Height": "vyska",
            "Width": "sirka"})
        .replace({
            "Bream": "Cejn",
            "Parkki": "Parma",
            "Perch": "Okoun",
            "Pike": "Štika",
            "Roach": "Plotice",
            "Smelt": "Šprota",
            "Whitefish": "Síh"})
)

data = read_fish_data("static/fish_data.csv")
data.sample(10)

data.groupby("druh")["druh"].count().sort_values(ascending=False)

# připravme data
y = data["druh"] == "Okoun"
X = data.drop(columns=["ID", "druh"])

# 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)

print(f"Trainset: {100 * y_train.sum()/len(y_train):.0f}%")
print(f"Testset:  {100 * y_test.sum()/len(y_test):.0f}%")

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train_raw)
X_test = scaler.transform(X_test_raw)

# vytvořme instanci třídy DecisionTreeClassifier
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
model

# natrénujte
model.fit(X_train, y_train);

# ohodnoťme validační množinu 
pred = model.predict(X_test) 

df_compare = (
    X_test_raw
    .assign(druh=y_test)
    .assign(predikce=pred)
)
df_compare["spravne"] = (df_compare["druh"] == df_compare["predikce"]).replace({True: "OK", False: ":("})
df_compare = df_compare.replace({True: "Okoun", False: "Ostatní"})

display(df_compare.sample(10))
print(f"Počet chyb ve validačních datech: {sum(y_test != pred)}")

print(f"Úspěšnost: {100*sum(y_test == pred)/len(y_test):.2f} %")

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier 
from sklearn.svm import SVC

# 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, 2):
    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")

from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix

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)
    }

import tqdm 
results = []
for name, model in tqdm.tqdm(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).sort_values(["test", "train"], ascending=False)
df_results.head(10)

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], 
                 markers=True, label="train", ax=ax)
    sns.lineplot(x="param", y="test", data=df_results[df_results["model"]==model_name], 
                 markers=True, 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)

# načtení data
test_data = read_fish_data("static/fish_data_test.csv")
y_real_test = test_data["druh"] == "Okoun"
y_real_test = y_real_test.astype(int)
X_real_test = test_data.drop(columns=["ID", "druh"])
X_real_test = scaler.transform(X_real_test)

# predikce
model = models[("SVC", 10**4)]
test_pred = model.predict(X_real_test)

df_compare = (
    pd.DataFrame()
    .assign(druh=y_real_test)
    .assign(predikce=test_pred)
)
df_compare["spravne"] = (df_compare["druh"] == df_compare["predikce"]).replace({True: "OK", False: ":("})
df_compare = df_compare.replace({True: "Okoun", False: "Ostatní"})

display(df_compare.sample(10))

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} %")

from sklearn.metrics import precision_score

precision_score(y_real_test, test_pred)

from sklearn.metrics import recall_score
recall_score(y_real_test, test_pred)

f1_score(y_real_test, test_pred)

data = read_fish_data("static/fish_data.csv")
data.sample(10)

y = data["druh"]
X = data.drop(columns=["druh", "ID"])

X_train_raw, X_test_raw, y_train, y_test =  train_test_split(X, y, stratify=y)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train_raw)
X_test = scaler.transform(X_test_raw)

klasifikator = SVC(class_weight="balanced", probability=True, C=10**5)
klasifikator.fit(X_train, y_train)

y_pred = klasifikator.predict(X_test)
y_pred

from sklearn.metrics import accuracy_score
100 * accuracy_score(y_test, y_pred)

from sklearn.metrics import ConfusionMatrixDisplay

ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred, labels=klasifikator.classes_
);