# Nástroje pro UI

Naprostá většina současných projektů v oblasti umělé inteligence a strojového učení se realizuje **v jazyce Python**. Je to zvláštní volba - Python je jeden z nejpomalejších běžně používaných jazyků a numerické výpočty jsou to poslední, na co byste ho čekali.

Vysvětlení je v tom, že v Pythonu se skoro nic nepočítá. Kombinace jednoduché syntaxe, bohatého ekosystému knihoven a **optimalizovaných numerických jader napsaných v C/C++ a CUDA** znamená, že Python jen říká, co se má stát, a stane se to jinde. Když napíšeš `A @ B`, proběhne to v BLAS knihovně napsané v assembleru. Python u toho čeká.

Tahle stránka je referenční - vrátíš se k ní, když budeš potřebovat příkaz nebo název funkce. Předpokládá to znalost Pythonu na úrovni „umím funkci a cyklus". Teorie za jednotlivými metodami je na [příznakových metodách](Priznakove-metody), [MLP](MLP-a-backpropagation) a dalších stránkách.

## Mapa nástrojů

| Skupina | K čemu | Knihovny |
|---|---|---|
| Základní numerické | práce s poli, tabulkami, statistika | **NumPy**, **Pandas** |
| Strojové učení | klasické algoritmy | **Scikit-learn** |
| Hluboké učení | trénování sítí na GPU | **PyTorch**, **TensorFlow** |
| Vizualizace | grafy, matice záměn | **Matplotlib**, **Seaborn** |
| Správa prostředí | izolované instalace balíků | **Anaconda/Conda** |

**Doporučení: nauč se Scikit-learn a NumPy pořádně, zbytek podle potřeby.** Většina úloh z téhle wiki se dá vyřešit deseti řádky ve Scikit-learn a hluboké učení potřebuješ, teprve když jde o obrázky, zvuk nebo text.

## Scikit-learn

Nejpoužívanější knihovna pro **klasické strojové učení**. Obsahuje desítky algoritmů se stejným, velmi jednoduchým programovým rozhraním.

### Jednotné API

Každý model (odhadovač, *estimator*) implementuje trojici metod:

- **`.fit(X, y)`** - natrénuje model na datech `X` s označeními `y`,
- **`.predict(X)`** - vrací predikce pro nová data,
- **`.score(X, y)`** - vrací přesnost modelu na daných datech.

**Tohle je nejužitečnější věc na celé knihovně.** Vyměníš `GaussianNB()` za `KNeighborsClassifier()` a nezměníš ani řádek zbytku kódu. Porovnání pěti klasifikátorů je pak cyklus přes seznam, ne pět různých programů - viz [příklad níž](#příklad-klasifikace-datové-sady-digits).

### Co v ní je

| Algoritmus | Třída | Stránka |
|---|---|---|
| K nejbližších sousedů | `KNeighborsClassifier` | [příznakové metody](Priznakove-metody#k-nejbližších-sousedů-k-nn) |
| Naivní Bayes | `GaussianNB`, `MultinomialNB` | [Bayesova klasifikace](Bayesova-klasifikace#naivní-bayes) |
| Support Vector Machines | `SVC`, `LinearSVC` | - |
| Rozhodovací stromy a lesy | `DecisionTreeClassifier`, `RandomForestClassifier` | [příznakové metody](Priznakove-metody#klasifikační-a-regresní-strom-cart) |
| Minimální vzdálenost | `NearestCentroid` | [příznakové metody](Priznakove-metody#klasifikátor-na-principu-minimální-vzdálenosti) |
| Lineární a logistická regrese | `LinearRegression`, `LogisticRegression` | [lineární regrese](Linearni-regrese) |
| Shlukování | `KMeans`, `DBSCAN` | [shlukování](Shlukovani) |

Velmi silnou stránkou knihovny je jednotná podpora pro **předzpracování dat** (škálování, PCA, dělení na trénovací a testovací množinu funkcí `train_test_split`) a pro **vyhodnocení** ([křížová validace](Metriky-a-vyhodnoceni#křížová-validace), metriky, matice záměn).

## NumPy a Pandas

### NumPy

Základní knihovna pro numerické výpočty. Jádrem je typ **`ndarray`** - n-rozměrné pole uložené **souvisle v paměti**. Umožňuje rychlé vektorové operace (sčítání, násobení matic, řešení soustav) bez nutnosti psát cykly v Pythonu.

**Prakticky všechny ML knihovny přijímají vstupy jako NumPy pole.** Výpočty v NumPy probíhají v optimalizovaném C kódu a jsou **řádově rychlejší než nativní Python smyčky**.

To „souvisle v paměti" je celý důvod. Pythonovský seznam je pole ukazatelů na objekty rozházené po haldě. NumPy pole je jeden blok bajtů, který procesor přečte naráz a zpracuje vektorovými instrukcemi.

```python
# správně - vektorově
vzdalenosti = np.sqrt(((X - stred)**2).sum(axis=1))

# špatně - Python cyklus, řádově pomalejší
vzdalenosti = [math.sqrt(sum((x[i]-stred[i])**2 for i in range(n))) for x in X]
```

### Pandas

Rozšiřuje NumPy o datové struktury inspirované tabulkami:

- **`Series`** - jednorozměrná řada s pojmenovaným indexem,
- **`DataFrame`** - dvourozměrná tabulka s pojmenovanými sloupci.

Hodí se pro načítání dat z CSV a Excelu, filtrování, agregaci, slučování tabulek a statistický průzkum dat. Úzce spolupracuje se Scikit-learn - **`DataFrame` se dá předat přímo do metody `.fit()`**.

## Matplotlib a Seaborn

**Matplotlib** je nejstarší a dodnes nejpoužívanější knihovna pro vykreslování 2D grafů. Modul `pyplot` poskytuje rozhraní podobné prostředí MATLABu.

| Funkce | Význam |
|---|---|
| `plt.plot(x, y)` | liniový graf |
| `plt.imshow(A)` | zobrazení matice nebo obrázku |
| `plt.hist(data)` | histogram |
| `plt.scatter(x, y)` | bodový graf |
| `plt.show()` | zobrazení figury |

**Seaborn** je nadstavba nad Matplotlibem zaměřená na statistické vizualizace - distribuční grafy, regresní diagramy, tepelné mapy korelací. Automaticky používá estetičtější výchozí styly.

Pro klasifikační úlohy se často kreslí [matice záměn](Metriky-a-vyhodnoceni#matice-záměn) pomocí třídy `ConfusionMatrixDisplay` ze Scikit-learn. Metoda `ConfusionMatrixDisplay.from_predictions(y_true, y_pred)` vykreslí matici přímo, bez nutnosti ručního výpočtu.

## Knihovny pro hluboké učení

### PyTorch

**Meta/Facebook AI, 2016.** Dnes nejpoužívanější framework v akademické sféře i ve výzkumu. Výpočetní graf se buduje **dynamicky (define-by-run)**, což je přirozené pro pythonovský styl programování a **zjednodušuje ladění** - můžeš do modelu vložit `print` nebo breakpoint a funguje to, protože se graf staví za běhu.

- tenzory (`torch.Tensor`) s podporou automatického derivování (**autograd**),
- vrstvy a modely (`torch.nn`),
- optimalizátory (`torch.optim`: SGD, Adam, RMSprop),
- běh na GPU pomocí CUDA (`.to("cuda")`).

Ten autograd je to, co ti ušetří ruční psaní [backpropagation](MLP-a-backpropagation#backpropagation). Zapíšeš dopředný průchod a knihovna si derivace odvodí sama.

### TensorFlow a Keras

**Google, 2015.** Druhý hlavní framework. Původně používal **statický** výpočetní graf, od verze 2.x podporuje i dynamický (eager) režim. Obsahuje vysokoúrovňové rozhraní **Keras**, v němž se modely staví velmi deklarativně:

```python
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax'),
])
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, batch_size=32)
```

Přečti si těch pár řádků optikou [MLP](MLP-a-backpropagation). `784` je vstup, tedy obrázek `28×28` zploštělý do vektoru. Dvě skryté vrstvy s ReLU. Výstup deset neuronů se **softmaxem**, tedy pravděpodobnostní rozdělení přes deset číslic. Optimalizátor Adam, ztráta křížová entropie. **Celá teorie z několika stránek se vejde do sedmi řádků** - a proto je důležité té teorii rozumět, protože jinak nebudeš mít co ladit, až to nebude fungovat.

### Hugging Face Transformers

Knihovna **Transformers** poskytuje stovky předtrénovaných modelů (BERT, GPT, T5) pro zpracování přirozeného jazyka, obrazu i zvuku. S několika řádky kódu lze model stáhnout a použít:

```python
from transformers import pipeline

clf = pipeline("sentiment-analysis")
print(clf("I really enjoyed this movie."))
# [{'label': 'POSITIVE', 'score': 0.9998}]
```

**Tohle je dnes výchozí postup u textových úloh.** Netrénuj [LSTM](Rekurentni-site-a-LSTM) od nuly, vezmi předtrénovaný model a dotrénuj jeho poslední vrstvu. Stejná úvaha jako [transfer learning u CNN](Konvolucni-site#kde-cnn-přestávají-platit).

## Anaconda a správa prostředí

**Anaconda** je distribuce jazyka Python zaměřená na vědecké výpočty. Obsahuje správce balíků **Conda**, který řeší závislosti mezi knihovnami **včetně ne-pythonovských** - CUDA, MKL. Minimální varianta se jmenuje **Miniconda**.

To je hlavní rozdíl proti `pip`. Pip umí jen Python balíky. Conda umí i nainstalovat správnou verzi CUDA k tvé grafické kartě, a to je přesně to místo, kde instalace hlubokého učení obvykle padne.

### Postup instalace

1. Stáhnout instalátor z `anaconda.com` pro příslušný operační systém.
2. Spustit instalaci - Windows klikací průvodce, Linux a macOS `bash Anaconda-*.sh`.
3. Ověřit instalaci příkazem `conda --version`.

### Tahák

```bash
conda create --name ui python=3.11        # vytvoření nového prostředí
conda activate ui                          # přepnutí do prostředí
conda deactivate                           # ukončení prostředí

conda install numpy pandas                 # instalace balíků
conda install -c conda-forge scikit-learn  # instalace z jiného kanálu

conda list                                 # výpis nainstalovaných balíků
conda env list                             # výpis všech prostředí
conda remove --name ui --all              # smazání prostředí
```

**Vždycky si založ prostředí pro projekt.** Instalace do základního prostředí skončí konfliktem verzí, typicky ve chvíli, kdy budeš potřebovat starší TensorFlow pro cizí kód.

### Google Colab

Alternativou bez vlastní instalace je **Google Colab** - webový notebook s **GPU/TPU zdarma**, předinstalovanými knihovnami a integrací na Google Drive. Vhodný zejména pro rychlé zkoušení a experimenty s hlubokým učením.

**Pro první projekt s neuronovou sítí je to nejrychlejší cesta.** Bez GPU trvá trénink [CNN](Konvolucni-site) na notebooku hodiny, v Colabu minuty. Omezení: session se po pár hodinách nečinnosti ukončí a data z ní zmizí, takže si výsledky průběžně ukládej na Drive.

## Příklad: klasifikace datové sady Digits

Praktická ukázka typického workflow. Dataset **Digits** obsahuje ručně psané číslice jako **šedotónové obrázky `8×8` v deseti třídách** a je součástí Scikit-learn.

### Načtení a vizualizace

```python
from sklearn import datasets
import matplotlib.pyplot as plt

digits = datasets.load_digits()
print(digits.data.shape)   # (1797, 64)

# zobrazeni prvnich 8 cislic
fig, axes = plt.subplots(1, 8, figsize=(10, 2))
for ax, img, lbl in zip(axes, digits.images, digits.target):
    ax.imshow(img, cmap='gray')
    ax.set_title(lbl); ax.axis('off')
plt.show()
```

To `(1797, 64)` je celý datový model: 1797 vzorků, každý jako vektor 64 čísel, tedy `8×8` pixelů zploštělých do řádku. **Prostorová struktura se tím ztratí** - a přesně tuhle informaci [CNN](Konvolucni-site) na rozdíl od klasických metod využívá.

### Trénování tří klasifikátorů

```python
from sklearn.model_selection import train_test_split
from sklearn.neighbors import NearestCentroid, KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, ConfusionMatrixDisplay

X_train, X_test, y_train, y_test = train_test_split(
    digits.data, digits.target, test_size=0.3, random_state=42)

modely = {
    "NearestCentroid":     NearestCentroid(),
    "KNN (k=3)":           KNeighborsClassifier(n_neighbors=3),
    "Gaussian Naive Bayes": GaussianNB(),
}

for jmeno, model in modely.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    acc = accuracy_score(y_test, y_pred)
    print(f"{jmeno:22s} accuracy = {acc:.3f}")
    ConfusionMatrixDisplay.from_predictions(y_test, y_pred)
    plt.title(jmeno); plt.show()
```

**Typické výsledky dosahují přesnosti kolem 90-98 %, přičemž KNN obvykle převyšuje jednoduchý NearestCentroid.** [Matice záměn](Metriky-a-vyhodnoceni#matice-záměn) pomáhá identifikovat, které číslice si model nejčastěji plete - typicky **8 versus 3**.

Tři věci na tom kódu stojí za zvýraznění:

**`random_state=42`** dělá rozdělení reprodukovatelné. Bez něj dostaneš pokaždé jinou přesnost a nebudeš vědět, jestli je rozdíl mezi modely skutečný, nebo jen šum.

**Cyklus přes slovník modelů** funguje jen díky jednotnému API. Tohle je ta úspora, o které byla řeč nahoře.

**Matice záměn se kreslí ke každému modelu**, ne jen přesnost. Samotné číslo neřekne, která číslice nefunguje.

## Časté chyby

**„Přesnost 98 %, hotovo."** U nevyvážených dat to nic neznamená. Podívej se na [matici záměn](Metriky-a-vyhodnoceni#matice-záměn) a na precision s recall.

**„Netrénoval jsem, jen jsem vybral příznaky na celých datech."** Testovací data už model ovlivnila a přesnost je nadhodnocená. Výběr příznaků patří dovnitř křížové validace.

**„Nemusím škálovat, je to jen k-NN."** Právě u k-NN a k-means na škálování všechno stojí. Viz [normalizace](Metriky-a-vyhodnoceni#základní-typy-dat).

**„Nainstaluju to pipem do systémového Pythonu."** Skončíš konfliktem verzí. Založ si conda prostředí.

**„Neuronová síť bude lepší než rozhodovací strom."** Na tabulkových datech obvykle není. Zkus obojí a změř to.

## Kam dál

- **[Příznakové metody](Priznakove-metody)** - teorie za `KNeighborsClassifier` a `DecisionTreeClassifier`
- **[Bayesova klasifikace](Bayesova-klasifikace)** - teorie za `GaussianNB`
- **[Metriky a vyhodnocení](Metriky-a-vyhodnoceni)** - co `accuracy_score` doopravdy měří a kdy lže
- **[MLP a backpropagation](MLP-a-backpropagation)** - co dělá `model.fit()` uvnitř
- **[Konvoluční sítě](Konvolucni-site)** - kdy sáhnout po PyTorchi místo Scikit-learn