Knihovna Scikit-learn, přehled užitečných funkcí

V předešlé hodině jsme se vyhýbali programování, jak jen se to dalo. Teď už si ale chceš také sama vše vyzkoušet. Abys mohla úlohu rozmyšlenou v domácím úkolu naprogramovat, projdeme si nejdůležitější funkce, které budeš potřebovat. Použijeme jednoduchá data salaries.csv

Především budeme používat knihovnu Scikit-learn a samozrejmě také pandas. Potřebné věci projdeme na příkladu.

import pandas as pd
import numpy as np
np.random.seed(42)

Načtení a příprava dat¶

☑ výběr vstupních proměnných

☑ rozdělení na trénovací a testovací data

☑ chybějící hodnoty

☑ kategorické hodnoty

☑ přeškálování / normování hodnot

Na začátku vždy bude potřeba připravit data. Čištění dat a použití knihovny pandas už bys měla ovládat, zaměříme se jen na věci, které jsou specifické pro strojové učení.

Načíst data tedy umíš.

df_salary = pd.read_csv("static/salaries.csv", index_col=0)
df_salary.sample(10)

Vytvoření trénovací a testovací množiny¶

Pro predikci použijeme jako příznaky rank, discipline, yrs.since.phd, yrs.service a sex, predikovat budeme hodnotu salary.

V teorii strojového učení se vstupy modelu (příznaky, vstupní proměnné) typicky označují písmenem X a výstupy písmenem y. Řada programátorů toto používá i k označování proměnných v kódu. X představuje matici (neboli tabulku), kde každý řádek odpovídá jednomu datovému vzorku a každý sloupec jednomu příznaku (vstupní proměnné). y je vektor, neboli jeden sloupec s odezvou.

(Na vyzobnutí odezvy se může hodit metoda pop. Její nevýhodou je ale nemožnost opakovaně spouštět buňku.)

y = df_salary["salary"]
X = df_salary.drop(columns=["salary"])

print(X.columns)
print(y.name)

Index(['rank', 'discipline', 'yrs.since.phd', 'yrs.service', 'sex'], dtype='object')
salary

X.head()

y.head()

1    139750
2    173200
3     79750
4    115000
5    141500
Name: salary, dtype: int64

Zbývá data rozdělit na trénovací a testovací, to je třeba udělat co nejdříve, abychom při různých konverzích dat používali jen informace z trénovací množiny a testovací množina byla opravdu jen k evaluaci. K tomu slouží metoda train_test_split. Data nám rozdělí náhodně na trénovací a testovací sadu. Velikost testovací množiny můžeme specifikovat parametrem test_size, jeho defaultní hodnota je 0.25, t. j. 25%.

from sklearn.model_selection import train_test_split 

X_train_raw, X_test_raw, y_train, y_test = train_test_split(X, y)
X_train_raw, X_test_raw, y_train, y_test = train_test_split(X, y, test_size=0.3)

Kódování vstupů¶

Pro učení potřebujeme všechny hondoty převést na čísla (float). Pokud by data obsahovala chybějící hodnoty, nejjednodušší řešení je takové řádky zahodit. (Bonus: pokud bys měla data s větším množstvím chybějících hodnot, podívej se na možnosti sklearn.impute)

Dále je důležité vypořádat se s kategorickými hodnotami. Sloupce obsahující hodnoty typu Boolean nebo dvě hodnoty (např. muž/žena), lze snadno převést na hodnoty $[0,1]$ .

Pro kategorické proměnné s více možnostmi použijeme tzv. onehot encoding.

Např. sloupec rank obsahuje hodnoty Prof, AsstProf a AssocProf. K zakódování pomocí onehot encoding potřebujeme tři sloupce:

Původní hodnota	Kód
Prof	1 0 0
AsstProf	0 1 0
AssocProf	0 0 1

Knihovna Scikitlearn nabízí sklearn.preprocessing.OneHotEncoder.

Při práci s pandas se může hodit i metoda get_dummies. (Pozn. dummies proto, že nám přibudou pomocné proměnné (sloupce), které se označují jako dummy variables.) Ale pozor, pokud budeme později potřebovat stejným způsobem zakódovat další data, musí obsahovat stejné kategorie.

pd.get_dummies(X_train_raw).head()

Naše data zakódujeme pomocí OneHotEncoder z knihovny Scikit-learn.

X_train_raw.columns

Index(['rank', 'discipline', 'yrs.since.phd', 'yrs.service', 'sex'], dtype='object')

categorical_columns = ["rank", "discipline"] 
numerical_columns = ["yrs.since.phd", "yrs.service"]
# zbývá sloupec sex

from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()

encoder.fit(X_train_raw[categorical_columns])
column_names = encoder.get_feature_names_out()

column_names

array(['rank_AssocProf', 'rank_AsstProf', 'rank_Prof', 'discipline_A',
       'discipline_B'], dtype=object)

encoder.transform(X_train_raw[categorical_columns])

<138x5 sparse matrix of type '<class 'numpy.float64'>'
	with 276 stored elements in Compressed Sparse Row format>

encoder1 = OneHotEncoder(sparse_output=False)
encoder1.fit(X_train_raw[categorical_columns])
encoder1.transform(X_train_raw[categorical_columns])

array([[0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [1., 0., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [1., 0., 0., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 1., 0., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [1., 0., 0., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 1., 0.],
       [1., 0., 0., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 1., 0.],
       [1., 0., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 1., 0.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 1., 0.],
       [1., 0., 0., 1., 0.],
       [0., 0., 1., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 1., 0.],
       [1., 0., 0., 1., 0.],
       [1., 0., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [1., 0., 0., 1., 0.],
       [0., 1., 0., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 1., 0., 0., 1.],
       [0., 0., 1., 0., 1.],
       [0., 0., 1., 0., 1.]])

from sklearn.compose import make_column_transformer

transformer = make_column_transformer(
    (OneHotEncoder(sparse_output=False, handle_unknown="ignore"),categorical_columns),
    remainder="passthrough"
)

transformer.fit(X_train_raw)
transformer.transform(X_train_raw)

array([[0.0, 1.0, 0.0, ..., 1, 0, 'Male'],
       [0.0, 1.0, 0.0, ..., 4, 4, 'Male'],
       [0.0, 0.0, 1.0, ..., 26, 19, 'Male'],
       ...,
       [0.0, 1.0, 0.0, ..., 3, 3, 'Female'],
       [0.0, 0.0, 1.0, ..., 25, 25, 'Female'],
       [0.0, 0.0, 1.0, ..., 15, 14, 'Male']], dtype=object)

transformer.get_feature_names_out()

array(['onehotencoder__rank_AssocProf', 'onehotencoder__rank_AsstProf',
       'onehotencoder__rank_Prof', 'onehotencoder__discipline_A',
       'onehotencoder__discipline_B', 'remainder__yrs.since.phd',
       'remainder__yrs.service', 'remainder__sex'], dtype=object)

from sklearn.preprocessing import OrdinalEncoder

transformer = make_column_transformer(
    (OneHotEncoder(sparse_output=False, handle_unknown="ignore"), categorical_columns),
    (OrdinalEncoder(), ["sex"]),
    remainder="passthrough"
)

X_train_transformed = transformer.fit_transform(X_train_raw)
X_test_transformed = transformer.transform(X_test_raw)

transformer.get_feature_names_out(), pd.DataFrame(X_test_transformed).head(10)

(array(['onehotencoder__rank_AssocProf', 'onehotencoder__rank_AsstProf',
        'onehotencoder__rank_Prof', 'onehotencoder__discipline_A',
        'onehotencoder__discipline_B', 'ordinalencoder__sex',
        'remainder__yrs.since.phd', 'remainder__yrs.service'], dtype=object),
      0    1    2    3    4    5     6     7
 0  1.0  0.0  0.0  1.0  0.0  1.0  19.0  16.0
 1  0.0  0.0  1.0  1.0  0.0  1.0  35.0  23.0
 2  0.0  0.0  1.0  0.0  1.0  1.0  17.0   3.0
 3  0.0  1.0  0.0  0.0  1.0  1.0   3.0   1.0
 4  1.0  0.0  0.0  0.0  1.0  1.0   8.0   8.0
 5  0.0  1.0  0.0  0.0  1.0  1.0   5.0   5.0
 6  1.0  0.0  0.0  0.0  1.0  1.0  12.0   8.0
 7  0.0  0.0  1.0  1.0  0.0  1.0  56.0  57.0
 8  0.0  1.0  0.0  1.0  0.0  0.0   3.0   1.0
 9  0.0  0.0  1.0  0.0  1.0  1.0  37.0  37.0)

Škálování¶

Přeškálování není vždy nutné, ale některým modelům to může pomoci. Řiďte se tedy pravidlem, že rozhodně neuškodí. Využijeme StandardScaler.

StandardScaler nám hodnoty přeškáluje, aby zhruba odpovídaly normálnímu rozdělení. Některé algoritmy to předpokládají. Pokud bychom neškálovali, mohlo by se stát, že příznak (sloupeček), která má výrazně větší rozptyl než ostatní, je brán jako významnější.

Nejprve si ukažme jednoduchý příklad.

from sklearn.preprocessing import StandardScaler 
import matplotlib.pyplot as plt
import seaborn as sns 

# vygeneruje 20 náhodných bodů
example = pd.DataFrame({"a": 100+np.random.randn(100), "b": 100*np.random.randn(100)})
example.head(20)

example.describe()

example_scaler = StandardScaler()
transformed_example = example_scaler.fit_transform(example)

fig, (ax1, ax2) = plt.subplots(ncols=2)
ax1.set_title("Histogram původních dat")
sns.histplot(example, ax=ax1)
ax2.set_title("Histogram přeškálovaných dat")
sns.histplot(transformed_example, ax=ax2);

pd.DataFrame(transformed_example).describe()

pd.DataFrame(transformed_example).head()

Zpátky k našim datům. Transformaci musíme nastavit (fit) pouze na trénovacích datech, škálovat pak budeme stejným způsobem trénovací i testovací data.

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train_transformed)
X_test = scaler.transform(X_test_transformed)

X_train

array([[-0.47036043,  1.85785169, -1.21007674, ...,  0.37482778,
        -1.52392312, -1.3377031 ],
       [-0.47036043,  1.85785169, -1.21007674, ...,  0.37482778,
        -1.27246669, -0.98473364],
       [-0.47036043, -0.5382561 ,  0.82639387, ...,  0.37482778,
         0.57154709,  0.33890184],
       ...,
       [-0.47036043,  1.85785169, -1.21007674, ..., -2.66789188,
        -1.3562855 , -1.072976  ],
       [-0.47036043, -0.5382561 ,  0.82639387, ..., -2.66789188,
         0.48772828,  0.86835603],
       [-0.47036043, -0.5382561 ,  0.82639387, ...,  0.37482778,
        -0.3504598 , -0.10230999]])

Modely¶

Můžeme přejít k samotnému učení. Vybereme si model. Přehled modelů najdeš v sekci Supervised learnig.

Na regresi můžeš použít:

LinearRegression
Lasso
- hyperparametry:
  - alpha, float, default=1.0
SVR
- hyperparametry:
  - kernel, default rbf, one of ‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’
  - C, float, optional (default=1.0)

Na klasifikační úlohy (ke kterým se dostaneme v příští hodině) využiješ:

DecisionTreeClassifier
RandomForestClassifier
- hyperparametry:
  - n_estimators, integer, optional (default=100)
SVC
- hyperparametry:
  - C, float, optional (default=1.0)
  - kernelstring, optional (default=’rbf’)

Vytvoříme instanci vybraného modelu (jde nám teď jen o způsob použití knihovny, vezmeme nejjednodušší lineární regresi):

from sklearn.linear_model import LinearRegression

model = LinearRegression()

Trénování¶

Model natrénujeme na trénovací množině:

model.fit(X_train, y_train)

Predikce¶

Natrénovaný model typicky chceme použít k ohodnocení nějakých nových datových vzorků, k tomu máme metodu predict. Zavolejme ji jak na trénovací, tak na testovací data.

train_predikce = model.predict(X_train)
test_predikce = model.predict(X_test)

Vypišme si prvních deset testovacích vzorků a jejich predikce:

print(f"skutečný plat    predicke platu     ")
for i in range(10):
    print(f"{y_test.iloc[i]:>10.2f}         {test_predikce[i]:>10.2f}")

skutečný plat    predicke platu     
  82100.00           85454.16
 134885.00          112335.62
 150480.00          126773.44
  86100.00           84785.42
 100000.00          102575.04
  91227.00           85896.89
 119800.00           99969.59
  76840.00          119177.70
  72500.00           68496.04
 152708.00          134266.88

Jednoduchý dotaz¶

Vyzkoušejte si zadat modelu svůj vlastní jednoduchý dotaz. K tomu můžete využít následující jednořádkový DataFrame.

dotaz = pd.DataFrame({
    "rank": "Prof",
    "discipline": "B",
    "yrs.since.phd": 15,
    "yrs.service": 10,
    "sex": "Male",
}, index=[0])
dotaz

X_query = scaler.transform(transformer.transform(dotaz))

print(f"Odhadovaný plat vašeho pracovníka je: {model.predict(X_query)[0]:.2f}")

Odhadovaný plat vašeho pracovníka je: 132301.01

Evaluace modelu¶

Můžeme využít funkci score, která nám vrátí hodnotu $R^2$ metriky:

print("R2 na trénovací množině: ", model.score(X_train, y_train))
print("R2 na testovací množině: ", model.score(X_test, y_test))

R2 na trénovací množině:  0.5135908532845631
R2 na testovací množině:  0.5444018189943942

Funkce pro všechny možné metriky najdeš v sklearn.metrics. (nyní nás zajímají regresní metriky)

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

MAE_train = mean_absolute_error(y_train, train_predikce)
MAE_test  = mean_absolute_error(y_test, test_predikce)

MSE_train = mean_squared_error(y_train, train_predikce) 
MSE_test = mean_squared_error(y_test, test_predikce)

R2_train = r2_score(y_train, train_predikce)
R2_test = r2_score(y_test, test_predikce)

print("    Trénovací data  Testovací data")
print(f"MSE {MSE_train:>14.3f}  {MSE_test:>14.3f}")
print(f"MAE {MAE_train:>14.3f}  {MAE_test:>14.3f}")
print(f"R2  {R2_train:>14.3f}  {R2_test:>14.3f}")

    Trénovací data  Testovací data
MSE  421032608.678   317260319.429
MAE      14436.169       13600.608
R2           0.514           0.544

Uložení modelu¶

Někdy si potřebujeme naučený model uchovat na další použití. Model lze uložit do souboru a zase načíst pomocí pickle. Kujme pikle:

import pickle 

with open("model.pickle", "wb") as soubor:
    pickle.dump(model, soubor)


with open("model.pickle", "rb") as soubor:
    staronovy_model = pickle.load(soubor)

staronovy_model.score(X_test, y_test)

0.5444018189943942

Bonusy:¶

volba vhodného modelu a jeho hyper-parametrů se skrývá pod klíčovým slovem model selection. Knihovna Scikit-learn obsahuje různé pomůcky k ulehčení toho výběru. Přesahuje to ale rámec tohoto kurzu, narazíš-li na to toho téma při samostudiu, pročti si sklear.model_selection.
v příkladu výše jsme použili různé transformace nad daty a pak teprve tvorbu modelu. Až budeš v těchto věcech zběhlejší, bude se ti hodit propojit tyto věci dohromady. K tomu slouží tzv. pipeline.

Strojové učení - úvod, regrese

Strojové učení - úvod do regrese

Strojové učení - Scikit-learn, ML workflow

Implementace domácího úkolu - rybí regrese