Nastroje-pro-UI.md

# 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ě: ```pythonfrom tensorflow.keras import Sequentialfrom 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: ```pythonfrom 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 ```bashconda 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 ```pythonfrom sklearn import datasetsimport matplotlib.pyplot as plt digits = datasets.load_digits()print(digits.data.shape)   # (1797, 64) # zobrazeni prvnich 8 cislicfig, 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ů ```pythonfrom sklearn.model_selection import train_test_splitfrom sklearn.neighbors import NearestCentroid, KNeighborsClassifierfrom sklearn.naive_bayes import GaussianNBfrom 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