Hlavní navigace

Neuronové sítě v knihovně scikit-learn: vytvoření a učení malé sítě

24. 9. 2024
Doba čtení: 46 minut

Sdílet

 Autor: Depositphotos
Dnes si ukážeme, jak vytvořit neuronovou síť s volitelným počtem skrytých vrstev, naučit tuto síť řešit zvolený problém s využitím sady trénovacích dat a následně tuto síť použít nad další sadou (validačních) dat.

Obsah

1. Neuronové sítě v knihovně scikit-learn

2. Idealizovaný model neuronu používaný v umělých neuronových sítích

3. Role biasu

4. Aktivační funkce

5. Vytvoření feed-forward sítě z jednotlivých neuronů

6. Vstupní vrstva, výstupní vrstva a skryté vrstvy neuronů

7. Trénink (učení) sítě s využitím trénovacích dat

8. Neuronová síť jako další typ modelu ve scikit-learn

9. Konstrukce neuronové sítě, její trénink a následné použití

10. Zobrazení vah neuronů v jednotlivých vrstvách

11. Zjištění přesnosti modelu vytvořeného neuronovou sítí, pomocí funkce accuracy_score

12. Konfigurace topologie neuronové sítě – počty neuronů ve skrytých vrstvách

13. Vliv počtu neuronů ve skrytých vrstvách na predikce neuronové sítě

14. Výsledky pro neuronovou síť s pěti skrytými vrstvami

15. Má další zvyšování počtu skrytých vrstev význam?

16. Lineární model provádějící regresi

17. Neuronová síť provádějící regresi

18. Změna počtu skrytých vrstev a neuronů v těchto vrstvách

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Neuronové sítě v knihovně scikit-learn

V dnešním článku o knihovně scikit-learn se budeme zabývat problematikou vytvoření jednoduchých umělých neuronových sítí (zkráceně jen neuronových sítí neboli neural network, popř. nn) a taktéž způsobem tréninku (učení) těchto sítí s jejich následnou křížovou validací. Již na začátku je nutné říct, že se sice jedná o dosti rozsáhlou problematiku, pro jejíž pochopení se navíc očekává alespoň základní znalost teorie neuronových sítí, na druhou stranu je však použití těchto sítí (ve funkci blackboxu) ve scikit-learn až triviálně jednoduché, vlastně stejně jednoduché, jako použití jiných modelů.

Zpočátku se zaměříme na neuronové sítě typu feed-forward s volitelným počtem vrstev neuronů, přičemž neurony na sousedních vrstvách budou propojeny (synapsemi) systémem „každý s každým“ a informace mezi neurony potečou pouze jedním směrem (forward). V dalších částech tohoto seriálu si popíšeme i další typy sítí, v nichž bude použito více vrstev neuronů, neurony budou propojeny odlišným způsobem, budou použity jiné aktivační funkce atd. (což již ovšem částečně přesahuje možnosti scikit-learn a sáhneme tedy například po pytorchi atd.

Neuronové sítě se používají zejména v těch projektech, v nichž je zapotřebí vytvořit funkční systém už ve chvíli, kdy ještě neznáme všechny možné kombinace vstupů a výstupů, popř. když je chování systému, který se implementuje, tak složité, že klasický návrh a implementace algoritmů by byl příliš zdlouhavý nebo s danými prostředky (čas, počet vývojářů a testerů) neefektivní. Jednou z nevýhod neuronových sítí může být to, že je někdy velmi obtížné zjistit, jaký problém jsme vlastně neuronovou síť naučili řešit. Výsledná síť se totiž (pokud se nebudeme hodně snažit zjisti více) chová jako blackbox, o němž není snadné říct, jaké konkrétní rozhodování ten který neuron provádí (v některých případech to ovšem možné je). Kritickou úlohu zde sehrává výběr vhodné množiny trénovacích dat. K tomu se však dostaneme až v dalších částech seriálu, v nichž se zmíníme o již existujících trénovacích datech.

Poznámka: již na úvod si však řekněme, že neuronové sítě jsou pro mnoho problémů příliš složitými modely, takže bývá snazší (a rychlejší) nejprve použít modely jednodušší.

2. Idealizovaný model neuronu používaný v umělých neuronových sítích

Při práci s umělými neuronovými sítěmi je vhodné vědět, jak je vlastně taková síť zkonstruována a z jakých prvků se skládá. Základním stavebním prvkem je umělý neuron, resp. velmi zjednodušený a idealizovaný model skutečného neuronu. Původní model neuronu byl navržen Warrenem McCullochem a Walterem Pittsem (MCP) již ve čtyřicátých letech minulého století, z čehož plyne, že neuronové sítě nejsou jen módním výstřelkem poslední doby (naopak, moderní GPU umožňují jejich nasazení i tam, kde to dříve nebylo možné, to je však téma na samostatný článek.). Na dalším obrázku jsou naznačeny prvky modelu neuronu:

Obrázek 1: Idealizovaný model neuronu.

Vidíme, že neuron může mít libovolný počet vstupů (na obrázku jsou tři vstupy x1, x2 a x3, ovšem může to být jen jeden vstup nebo i sto vstupů) a má pouze jeden výstup y. Vstupem a výstupem jsou reálná čísla; typicky bývá výstup upraven aktivační funkcí tak, že leží v rozsahu ← 1..1> nebo <0..1>.

Dále na schématu vidíme váhy w1, w2 a w3. Těmito váhami jsou vynásobeny vstupní hodnoty. Váhy vlastně představují stav neuronu, tj. o funkci, na kterou byl neuron natrénován (naučen). Vstupní hodnoty x1xn jsou tedy postupně vynásobeny váhami w1wn a výsledky součinu jsou v neuronu sečteny, takže získáme jediné reálné číslo. Toto číslo je zpracováno aktivační funkcí (ta již většinou žádný stav nemá, ostatně stejně jako funkce pro výpočet sumy) výsledek této funkce je poslán na výstup neuronu.

Neuron tedy provádí tento výpočet:

y = f(w1x1 + w2x2 + … + wnxn)

3. Role biasu

Ve skutečnosti není stav neuronu pro n vstupů x1xn určen pouze n vahami w1wn. Musíme přidat ještě váhu w0, na kterou je připojena konstanta 1 (někdy se proto můžeme setkat s nákresem neuronové sítě, v níž se nachází speciální neurony bez vstupů a s jedničkou na výstupu). Model neuronu se přidáním nového vstupu nepatrně zkomplikuje:

Obrázek 2: Idealizovaný model neuronu s biasem.

I výpočet bude vypadat (nepatrně) odlišně, neboť do něho přidáme nový člen:

y = f(w0 + w1x1 + w2x2 + … + wnxn)

Tato přidaná váha se někdy nazývá bias, protože vlastně umožňuje posouvat průběh aktivační funkce nalevo a napravo, v závislosti na jeho hodnotě.

4. Aktivační funkce

Bez aktivační funkce by se neuron choval jednoduše – spočítal by vážený součet vstupů a výsledek by poslal na výstup. Aktivační funkce, kterou jsme v předchozích dvou kapitolách označovali symbolem f, do celého výpočtu vnáší nelinearitu (ta je velmi důležitá). Nejjednodušší aktivační funkce může pro vstupní hodnoty <0 vracet –1 a pro hodnoty ≥0 vracet 1, což vlastně říká, že je nutné dosáhnout určité hraniční hodnoty váženého součtu vstupů, aby byl neuron aktivován (tj. na výstup vyslal jedničku a nikoli –1). Ostatně právě zde znovu vidíme význam biasu, který onu hraniční hodnotu posunuje.

Obrázek 3: Aktivační funkce ReLU.

V praxi je však aktivační funkce složitější, než zmíněný jednotkový skok. Často se používá ReLU, sigmoid nebo hyperbolický tangent. Pro specializovanější účely se však používají i další funkce, které dokonce nemusí mít monotonní průběh. S dalšími podporovanými funkcemi se seznámíme příště.

Obrázek 4: Aktivační funkce Tanh.

5. Vytvoření feed-forward sítě z jednotlivých neuronů

Samostatné neurony i s aktivační funkcí stále provádí velmi jednoduchou činnost, ovšem aby se mohly stát součástí složitějšího systému (řekněme automatického řízení auta), musíme z nich vytvořit síť. Jedna z nejjednodušších forem umělé neuronové sítě se nazývá feed-forward, a to z toho důvodu, že informace (tedy vstupní hodnoty, mezihodnoty i hodnoty výstupní) touto sítí tečou jen jedním směrem (při učení je tomu jinak). Neurony jsou uspořádány pravidelně do vrstev:

Obrázek 5: Uspořádání neuronů do vrstev ve feed-forward síti.

Kolečka na obrázku představují jednotlivé neurony, přičemž žlutě jsou označeny neurony na vstupu, zeleně „interní“ (skryté) neurony a červeně neurony, které produkují kýžený výstup neuronové sítě.

Zcela nalevo jsou šipkami naznačeny vstupy. Jejich počet je prakticky zcela závislý na řešeném problému. Může se jednat jen o několik vstupů (viz naše testovací síť popsaná níže), ovšem pokud například budeme tvořit síť určenou pro rozpoznání objektů v rastrovém obrázku, může být počet vstupů roven počtu pixelů (což ovšem v praxi realizujeme odlišně – konvolučními sítěmi).

6. Vstupní vrstva, výstupní vrstva a skryté vrstvy neuronů

Vraťme se ještě jednou k obrázku číslo 5.

Povšimněte si, že vstupní neurony mají vlastně zjednodušenou funkci, protože mají jen jeden vstup. V mnoha typech sítí tyto neurony jen rozesílají vstup na další neurony a neprovádí žádný složitější výpočet, například u nich není použita aktivační funkce, ovšem to již záleží na konkrétní konfiguraci sítě. Dále stojí za povšimnutí, že neurony posílají svůj výstup neuronům na nejbližší další vrstvě; nejsou zde tedy žádné zkratky, žádné zpětné vazby atd.

Existují samozřejmě složitější typy sítí, těmi se teď ale nebudeme zabývat. Dále tato síť propojuje neurony na sousedních vrstvách systémem „každý s každým“. V našem konkrétním příkladu mají neurony na prostřední vrstvě dva vstupy, protože předchozí vrstva má jen dva neurony. Ovšem neurony na poslední vrstvě již musí mít tři vstupy.

Poznámka: může se stát, že síť bude po naučení obsahovat neurony, jejichž váhy na vstupu budou nulové. To vlastně značí, že ze sítě některé spoje (šipky) zmizí, protože vynásobením jakéhokoli vstupu nulou dostaneme zase jen nulu.

První vrstva s jednoduchými („hloupými“) neurony se nazývá vstupní vrstva, poslední vrstva je vrstva výstupní. Vrstvy mezi vrstvou vstupní a výstupní, kterých může být teoreticky libovolné množství, se nazývají skryté vrstvy.

„Paměť“ neuronové sítě je tvořena vahami na vstupech neuronů (včetně biasu):

Vrstva Neuronů Počet vstupů/neuron Počet vah/neuron Celkem
1 2 1 2 4
2 3 2 3 9
3 2 3 4 8
7     21

V praxi se používají sítě s více vrstvami a především s větším počtem neuronů v každé vrstvě. Stavový prostor a tím i schopnosti sítě se tak prudce rozšiřují (viz již zmíněná problematika rozpoznávání objektů v rastrových obrázcích).

Poznámka: někdy se počet neuronů v umělých sítích porovnává s počtem neuronů v mozku, ale to je ve skutečnosti dost zavádějící, neboť záleží spíše na uspořádání sítě, složitosti neuronů (více výstupů) atd. A pravděpodobně mnoho věcí o mozku ještě neznáme.

7. Trénink (učení) sítě s využitím trénovacích dat

Nejzajímavější je proces tréninku (učení) sítě. Ten může probíhat několika způsoby, ovšem nejčastější je učení založené na tom, že na vstup sítě přivedeme data, u nichž dopředu známe očekávaný výsledek. Síť pro tato vstupní data provede svůj odhad a na základě rozdílů mezi odhadem sítě a očekávaným výsledkem se více či méně sofistikovanými algoritmy nepatrně pozmění váhy wi na vstupech do neuronů (včetně biasu, tedy w0).

Konkrétní míra změn váhy na vstupech neuronů je globálně řízena dalším parametrem či parametry, z nichž ten nejdůležitější ovlivňuje rychlost učení. Ta by neměla být příliš nízká (to vyžaduje objemná trénovací data nebo jejich opakování), ale ani příliš vysoká. Základní algoritmus učení sítě se jmenuje backpropagation, protože se váhy skutečně mění v opačném směru – od výstupů (na něž se přivede vypočtená chyba) ke vstupům. Asi nejlépe je tento koncept popsán v článku dostupném na adrese https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/, tuto část za nás však vykoná knihovna scikit-learn zcela automaticky.

8. Neuronová síť jako další typ modelu ve scikit-learn

V knihovně scikit-learn se s neuronovými sítěmi pracuje prakticky stejným způsobem, jako s dalšími typy modelů. Implementace neuronových sítí tedy dělíme na klasifikátory a na sítě/modely provádějící regresi. Připomeňme si tedy, jakým způsobem se vytvoří model (NEzaložený na neuronové síti), který bude provádět klasifikaci, tj. na základě vstupu oznámí, že výstupní hodnota spadá do určité kategorie. V našem konkrétním případě se bude jednat o datovou sadu Iris a budeme rozlišovat čtyři možné druhy květin. Použijeme model KNeighborsClassifier:

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import numpy as np
 
 
# nacteni datove sady
iris = load_iris()
 
# konstrukce klasifikatoru
# (s hyperparametrem)
classifier = KNeighborsClassifier(n_neighbors=1)
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
# rozdělení na trénovací a testovací data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 
# trening modelu
classifier.fit(X_train, y_train)
 
# očekávané výsledky
expexted_labels = y_test
 
# výsledky modelu (predikované výsledky)
predicted_labels = classifier.predict(X_test)
 
# jak je náš model úspěšný?
total = 0
same = 0
 
# porovnání predikce s očekáváním
for (expected, predicted) in zip(expexted_labels, predicted_labels):
    if expected==predicted:
        same+=1
    total+=1
 
print(f"total:    {total}")
print(f"same:     {same}")
print(f"accuracy: {100.0*same/total:4.1f}%")

Po spuštění tohoto skriptu se zobrazí, že z třiceti vstupů (20% ze vstupní datové sady se 150 záznamy) se dobře klasifikovalo 29 vstupů a přesnost modelu je tedy 96,7%:

total:    30
same:     29
accuracy: 96.7%

9. Konstrukce neuronové sítě, její trénink a následné použití

Nyní provedeme jednoduchou záměnu – namísto modelu KNeighborsClassifier použijeme model MLPClassifier, což je model založený na neuronové síti (MLP znamená MultiLayer Perceptron). Model natrénujeme naprosto stejným způsobem, jako model z předchozí kapitoly, a následně jej i naprosto stejným způsobem otestujeme:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
# nacteni datove sady
iris = load_iris()
 
# konstrukce klasifikatoru
# (s hyperparametrem)
classifier = MLPClassifier(max_iter=5000)
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
# rozdělení na trénovací a testovací data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 
# trening modelu
classifier.fit(X_train, y_train)
 
# očekávané výsledky
expexted_labels = y_test
 
# výsledky modelu (predikované výsledky)
predicted_labels = classifier.predict(X_test)
 
# jak je náš model úspěšný?
total = 0
same = 0
 
# porovnání predikce s očekáváním
for (expected, predicted) in zip(expexted_labels, predicted_labels):
    if expected==predicted:
        same+=1
    total+=1
 
print(f"total:    {total}")
print(f"same:     {same}")
print(f"accuracy: {100.0*same/total:4.1f}%")
 
print(f"Features: {classifier.n_features_in_}")
print(f"Layers:   {classifier.n_layers_}")
print(f"Outputs:  {classifier.n_outputs_}")
print("Weights:")
 
for layer, weights in enumerate(classifier.coefs_):
    print("\t", layer, weights.shape)
 
print("Biases:")
 
for layer, biases in enumerate(classifier.intercepts_):
    print("\t", layer, biases.shape)

Výsledky pro několik běhů naznačují, že se při tréninku sítě používají náhodné hodnoty a tudíž výsledky nebudou vždy totožné:

total:    30
same:     30
accuracy: 100.0%

Další běh:

total:    30
same:     28
accuracy: 93.3%
Poznámka: neuronová síť tedy nemusí být (a ani nebývá) „chytřejší“, než jiné typy modelů!

10. Zobrazení vah neuronů v jednotlivých vrstvách

Povšimněte si, že na konci předchozího skriptu (po zjištění přesnosti modelu) si ještě necháme vypsat základní informace o neuronové síti. Zejména se vypíšou informace o počtu vstupů (features), počtu hladin (layers) i o počtu výstupů (outputs):

print(f"Features: {classifier.n_features_in_}")
print(f"Layers:   {classifier.n_layers_}")
print(f"Outputs:  {classifier.n_outputs_}")
print("Weights:")

Pro datovou sadu Iris se vypíše:

Features: 4
Layers:   3
Outputs:  3

Tj. bude se jednat o neuronovou síť, kde vstupní vrstva má čtyři neurony, výstupní vrstva má tři neurony (rozlišujeme tři druhy květin) a celkový počet vrstev bude roven třem (tedy k dispozici je jen jedna skrytá vrstva).

Dále si můžeme vypsat váhy vstupů jednotlivých neuronů i hodnoty bias:

 
for layer, weights in enumerate(classifier.coefs_):
    print("\t", layer, weights.shape)
 
print("Biases:")
 
for layer, biases in enumerate(classifier.intercepts_):
    print("\t", layer, biases.shape)

Výsledky:

Weights:
         0 (4, 100)
         1 (100, 3)
Biases:
         0 (100,)
         1 (3,)

Jak tyto údaje číst? Skrytá vrstva má sto neuronů, takže se propojuje stylem 4:100:3. Váhy jsou uloženy ve formě dvourozměrných matic s hodnotami typu float. A hodnoty bias jsou uloženy pro každou vrstvu formou vektorů (není zde realizováno propojení „každý s každým“, jde jen o vstup konstant do neuronů.

Pro neuronovou síť se třemi skrytými vrstvami, z nich každá má 10 neuronů, bude výstup vypadat následovně:

Features: 4
Layers:   5
Outputs:  3
Weights:
         0 (4, 10)
         1 (10, 10)
         2 (10, 10)
         3 (10, 3)
Biases:
         0 (10,)
         1 (10,)
         2 (10,)
         3 (3,)

11. Zjištění přesnosti modelu vytvořeného neuronovou sítí, pomocí funkce accuracy_score

Podobně jako u dalších typů modelů pochopitelně můžeme i u neuronových sítí zjistit přesnost modelu kombinací funkcí train_test_split a accuracy_score. Výsledkem by měly být podobné hodnoty, jaké jsme dostali v předchozím skriptu:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
 
from sklearn.metrics import accuracy_score
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
# nacteni datove sady
iris = load_iris()
 
# konstrukce klasifikatoru
# (s hyperparametrem)
classifier = MLPClassifier(max_iter=5000)
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
# rozdělení na trénovací a testovací data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 
# trening modelu
classifier.fit(X_train, y_train)
 
 
# výsledky modelu (predikované výsledky)
y_pred = classifier.predict(X_test)
 
# vypoctena presnost modelu
print(accuracy_score(y_test, y_pred))
 
print(f"Features: {classifier.n_features_in_}")
print(f"Layers:   {classifier.n_layers_}")
print(f"Outputs:  {classifier.n_outputs_}")
print("Weights:")
 
for layer, weights in enumerate(classifier.coefs_):
    print("\t", layer, weights.shape)
 
print("Biases:")
 
for layer, biases in enumerate(classifier.intercepts_):
    print("\t", layer, biases.shape)

Skóre při prvním spuštění:

0.9666666666666667

Při dalším spuštění může být skóre vyšší (nebo nižší). Já měl štěstí – vyšel mi 100% korektní model:

1.0

A nakonec se opět vypíše konfigurace naučené neuronové sítě:

Features: 4
Layers:   3
Outputs:  3
Weights:
         0 (4, 100)
         1 (100, 3)

12. Konfigurace topologie neuronové sítě – počty neuronů ve skrytých vrstvách

Knihovna scikit-learn umožňuje částečnou konfiguraci topologie neuronové sítě. Volit totiž můžeme počty neuronů v jednotlivých skrytých vrstvách (nikoli ve vrstvě vstupní ani ve vrstvě výstupní – což je logické). Dosáhneme toho následujícím konstruktorem:

classifier = MLPClassifier(max_iter=5000, hidden_layer_sizes = (počet_neuronů_ve_vrstvě1, počet_neuronů_ve_vrstvě2, ...))

To tedy znamená, že se počet neuronů předává ve formě n-tice, kde počet členů určí počet skrytých vrstev.

Ukažme si celý postup na jednoduchém demonstračním příkladu, v němž vytvoříme neuronovou síť se třemi skrytými vrstvami, přičemž každá vrstva bude obsahovat deset neuronů:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
 
from sklearn.metrics import accuracy_score
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
# nacteni datove sady
iris = load_iris()
 
# konstrukce klasifikatoru
# (s hyperparametrem)
classifier = MLPClassifier(max_iter=5000, hidden_layer_sizes = (10, 10, 10))
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
# rozdělení na trénovací a testovací data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 
# trening modelu
classifier.fit(X_train, y_train)
 
 
# výsledky modelu (predikované výsledky)
y_pred = classifier.predict(X_test)
 
# vypoctena presnost modelu
print(accuracy_score(y_test, y_pred))
 
print(f"Features: {classifier.n_features_in_}")
print(f"Layers:   {classifier.n_layers_}")
print(f"Outputs:  {classifier.n_outputs_}")
print("Weights:")
 
for layer, weights in enumerate(classifier.coefs_):
    print("\t", layer, weights.shape)
 
print("Biases:")
 
for layer, biases in enumerate(nn.intercepts_):
    print("\t", layer, biases.shape)

Postupně získávané výsledky (přesnosti predikce modelu):

0.9666666666666667
0.9333333333333333
1.0

Zajímavá bude informace o samotné neuronové síti. Povšimněte si, že nyní je počet vrstev roven 1+3+1=5 a že váhy odpovídají tomu, že skryté vrstvy budou mít každá deset neuronů:

Features: 4
Layers:   5
Outputs:  3
Weights:
         0 (4, 10)
         1 (10, 10)
         2 (10, 10)
         3 (10, 3)
Biases:
         0 (10,)
         1 (10,)
         2 (10,)
         3 (3,)

13. Vliv počtu neuronů ve skrytých vrstvách na predikce neuronové sítě

Mohlo by se zdát, že větší neuronová síť (tedy více neuronů) může znamenat, že dostaneme i kvalitnější model a lepší výsledky. Ovšem v praxi můžeme narazit na úplný opak, a to ve chvíli, kdy se neuronová síť nedokáže správně zaučit – datová sada je buď příliš malá, nebo je neuronů tolik, že gradient při změně jejich vah je příliš malý nebo dokonce nulový. Ovšem zaměřme se nejdříve na případ, kdy vyšší počet neuronů má dobrý vliv na kvalitu modelu. Ostatně si to můžeme snadno ukázat – pro naši síť se třemi skrytými vrstvami budeme postupně zvyšovat počet neuronů v těchto vrstvách od 1 do 19 a budeme počítat úspěšnost takového modelu:

import matplotlib.pyplot as plt
 
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
# nacteni datove sady
iris = load_iris()
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
avg_scores = []
 
r = range(1, 20)
 
# hledani optimalniho poctu neuronu ve vrstvach
for neurons in r:
    # konstrukce klasifikatoru
    # (s hyperparametrem)
    classifier = MLPClassifier(max_iter=5000, hidden_layer_sizes = (neurons, neurons, neurons))
 
    # vypocet skore
    scores = cross_val_score(classifier, X, y, cv=10, scoring='accuracy')
 
    avg_score = scores.mean()
 
    # vypsani prumerneho skore do tabulky
    print(neurons, avg_score)
 
    avg_scores.append(avg_score)
 
plt.plot(r, avg_scores)
plt.xlabel("Změna počtu neuronů ve třech vrstvách")
plt.ylabel("Přesnost modelu")
 
# ulozeni grafu do souboru
plt.savefig("139.png")
 
# vykresleni grafu na obrazovku
plt.show()

Numerické výsledky ukazují, že pro cca 8 neuronů ve vrstvě jsme dosáhli optimálního bodu:

1 0.33333333333333337
2 0.6533333333333333
3 0.7533333333333332
4 0.76
5 0.9666666666666668
6 0.9066666666666666
7 0.9466666666666667
8 0.9866666666666667
9 0.9866666666666667
10 0.9866666666666667
11 0.9666666666666668
12 0.9733333333333334
13 0.9666666666666668
14 0.9733333333333334
15 0.9733333333333334
16 0.9733333333333334
17 0.9733333333333334
18 0.9733333333333334
19 0.9733333333333334

Ještě lépe je to vidět na vykresleném grafu:

Obrázek 6: Vliv počtu neuronů na kvalitu modelu.

14. Výsledky pro neuronovou síť s pěti skrytými vrstvami

Pokusme se nyní zvýšit počet skrytých vrstev ze tří na pět. Skript bude prakticky stejný, jako tomu bylo v předchozí kapitole, pouze se změní n-tice předávaná do konstruktoru MLPClassifier. Nyní budeme specifikovat pět vrstev (hodnot v n-tici) a nikoli vrstvy tři:

import matplotlib.pyplot as plt
 
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
# nacteni datove sady
iris = load_iris()
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
avg_scores = []
 
r = range(1, 20)
 
# hledani optimalniho poctu neuronu ve vrstvach
for neurons in r:
    # konstrukce klasifikatoru
    # (s hyperparametrem)
    classifier = MLPClassifier(max_iter=5000, hidden_layer_sizes = (neurons, neurons, neurons, neurons, neurons))
 
    # vypocet skore
    scores = cross_val_score(classifier, X, y, cv=10, scoring='accuracy')
 
    avg_score = scores.mean()
 
    # vypsani prumerneho skore do tabulky
    print(neurons, avg_score)
 
    avg_scores.append(avg_score)
 
plt.plot(r, avg_scores)
plt.xlabel("Změna počtu neuronů v pěti vrstvách")
plt.ylabel("Přesnost modelu")
 
# ulozeni grafu do souboru
plt.savefig("140.png")
 
# vykresleni grafu na obrazovku
plt.show()

Výsledky nyní budou (na první pohled možná poněkud paradoxně) nepatrně horší, než tomu bylo v předchozím příkladu:

1 0.33333333333333337
2 0.4666666666666666
3 0.7133333333333333
4 0.7
5 0.9066666666666666
6 0.9733333333333334
7 0.9866666666666667
8 0.9133333333333333
9 0.9133333333333333
10 0.9733333333333334
11 0.9866666666666667
12 0.9866666666666667
13 0.9733333333333334
14 0.9733333333333334
15 0.9800000000000001
16 0.9733333333333334
17 0.9800000000000001
18 0.9800000000000001
19 0.9733333333333334

Grafické znázornění výsledků:

Obrázek 7: Vliv počtu neuronů na kvalitu modelu.

15. Má další zvyšování počtu skrytých vrstev význam?

Zajímavé bude taktéž zjistit, jestli má vůbec smysl zvyšovat počet skrytých vrstev nad určitou ideální hodnotu. Opět si to můžeme vyzkoušet, a to tak, že budeme měnit počet prvků v n-tici hidden_layer_sizes:

NEURONS = 5
r = range(1, 40)
 
# hledani optimalniho poctu neuronu ve vrstvach
for layers in r:
    # konstrukce klasifikatoru
    # (s hyperparametrem)
    layer_sizes = (NEURONS, ) * layers
    classifier = MLPClassifier(max_iter=5000, hidden_layer_sizes = layer_sizes)
Poznámka: pozor – tento skript bude běžet velmi dlouho, i několik hodin:
import matplotlib.pyplot as plt
 
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
# nacteni datove sady
iris = load_iris()
 
# X je matice (feature matrix)
X = iris.data
 
# y je vektor (response vector)
y = iris.target
 
avg_scores = []
 
NEURONS = 5
r = range(1, 40)
 
# hledani optimalniho poctu neuronu ve vrstvach
for layers in r:
    # konstrukce klasifikatoru
    # (s hyperparametrem)
    layer_sizes = (NEURONS, ) * layers
    classifier = MLPClassifier(max_iter=5000, hidden_layer_sizes = layer_sizes)
 
    # vypocet skore
    scores = cross_val_score(classifier, X, y, cv=10, scoring='accuracy')
 
    avg_score = scores.mean()
 
    # vypsani prumerneho skore do tabulky
    print(layers, avg_score)
 
    avg_scores.append(avg_score)
 
plt.plot(r, avg_scores)
plt.xlabel("Změna počtu vrstev")
plt.ylabel("Přesnost modelu")
 
# ulozeni grafu do souboru
plt.savefig("141.png")
 
# vykresleni grafu na obrazovku
plt.show()

Nyní jsou výsledky dosti odlišné od předchozích dvou výsledků, protože se model nejenom přestane zlepšovat, ale od cca 4–5 skrytých vrstev se naopak začíná zhoršovat, a to dosti podstatným způsobem (až k tomu, že začne hádat – což přesně odpovídá hodnotě 1/3, protože klasifikujeme jen tři druhy rostlin, a na hádání nám stačí funkce RND a nikoli neuronová síť):

1 0.9666666666666668
2 0.9800000000000001
3 0.8466666666666667
4 0.9733333333333334
5 0.9733333333333334
6 0.7133333333333333
7 0.8733333333333334
8 0.8866666666666667
9 0.5999999999999999
10 0.7466666666666667
11 0.7333333333333333
12 0.6799999999999999
13 0.5866666666666667
14 0.8066666666666666
15 0.4666666666666666
16 0.4666666666666666
17 0.4533333333333333
18 0.4333333333333333
19 0.39333333333333337
20 0.4
21 0.33333333333333337
22 0.33333333333333337
23 0.44666666666666666
24 0.33333333333333337
25 0.42000000000000004
26 0.4
27 0.33333333333333337
28 0.33333333333333337
29 0.33333333333333337
30 0.33333333333333337
31 0.33333333333333337
32 0.33333333333333337
33 0.33333333333333337
34 0.33333333333333337
35 0.33333333333333337
36 0.33333333333333337
37 0.33333333333333337
38 0.33333333333333337
39 0.33333333333333337

Grafické znázornění výsledků:

Obrázek 8: Vliv počtu skrytých vrstev na kvalitu modelu.

16. Lineární model provádějící regresi

V první části článku jsme si ukázali, jak podobné je použití libovolného modelu pro klasifikaci s neuronovou sítí, která taktéž provádí klasifikaci. Ovšem prakticky totéž platí i pro vztah mezi modely pro regresi a neuronovou sítí provádějící taktéž regresi (tedy zjednodušeně řečeno odhad numerické hodnoty z nějakého intervalu). Zopakujme si tedy, jak lze použít jednoduchý model pro lineární regresi a následně zjistit jeho (ne)přesnost. Použijeme přitom naši známou datovou sadu California Housings:

from sklearn import linear_model
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
 
# nacteni datove sady
housings = fetch_california_housing()
 
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
 
# ceny bloku
targets = housings["target"]
 
# X je matice, y je vektor
X = data
y = targets
 
# rozdeleni dat na treninkovou a testovaci mnozinu
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.6)
 
# konstrukce modelu
lr = linear_model.LinearRegression()
 
# trénink modelu
lr.fit(X_train, y_train)
 
# predikce modelu
y_pred = lr.predict(X_test)
 
# výpis vypočtených koeficientů modelu
print("Coefficients: \n", lr.coef_)
print("Intercept: \n", lr.intercept_)
 
# chyba predikce
print("Mean squared error: %.2f" % mean_squared_error(y_test, y_pred))
 
# 1 = nejlepší predikce modelu
print("Coefficient of determination: %.2f" % r2_score(y_test, y_pred))

Po spuštění tohoto skriptu se zobrazí koeficienty lineárního modelu a následně i přesnost (zde spíše nepatrná nepřesnost) odhadu výsledků:

Coefficients:
 [ 4.45786809e-01  9.72953693e-03 -1.35720128e-01  8.20514635e-01
 -1.33231372e-06 -2.84786314e-03 -4.16735165e-01 -4.31811104e-01]
Intercept:
 -36.869534449989914
Mean squared error: 0.53
Coefficient of determination: 0.61

17. Neuronová síť provádějící regresi

Nyní namísto modelu LinearRegression použijeme model nazvaný MLPRegressor. Jedná se o model založený na neuronové síti, který dokáže provádět regresi. A navíc do skriptu přidáme i (nyní známou) část, která vypíše základní parametry zkonstruované a natrénované neuronové sítě:

# model zalozeny na neuronove siti
from sklearn.neural_network import MLPRegressor
 
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
 
# nacteni datove sady
housings = fetch_california_housing()
 
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
 
# ceny bloku
targets = housings["target"]
 
# X je matice, y je vektor
X = data
y = targets
 
# rozdeleni dat na treninkovou a testovaci mnozinu
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)
 
# konstrukce modelu
nn = MLPRegressor(max_iter=5000)
 
# trénink modelu
nn.fit(X_train, y_train)
 
# predikce modelu
y_pred = nn.predict(X_test)
 
# chyba predikce
print("Mean squared error: %.2f" % mean_squared_error(y_test, y_pred))
 
# 1 = nejlepší predikce modelu
print("Coefficient of determination: %.2f" % r2_score(y_test, y_pred))
 
print(f"Features: {nn.n_features_in_}")
print(f"Layers:   {nn.n_layers_}")
print(f"Outputs:  {nn.n_outputs_}")
print("Weights:")
 
for layer, weights in enumerate(nn.coefs_):
    print("\t", layer, weights.shape)
 
print("Biases:")
 
for layer, biases in enumerate(nn.intercepts_):
    print("\t", layer, biases.shape)

Po spuštění tohoto skriptu se opět nejdříve zobrazí výsledek validace modelu (s nepříliš lichotivými výsledky):

Mean squared error: 1.34
Coefficient of determination: -0.01

Posléze se zobrazí informace o neuronové síti. Ve vstupní vrstvě je osm neuronů, což odpovídá počtu atributů, na které byla síť natrénována. Výstupní vrstva má jeden neuron, což je opět pochopitelné, protože výstupem má být jediné reálné číslo. A celkový počet vrstev je roven třem – tedy kromě vstupní vrstvy a vrstvy výstupní máme jedinou skrytou vrstvu:

Features: 8
Layers:   3
Outputs:  1

Posledními údaji, které skript uvedený v této kapitole zobrazí, jsou tvary (shape) polí s váhami neuronů a taktéž pole s hodnotami bias. Tvary těchto polí plně odpovídají očekávané topologii neuronové sítě (tedy vazby 8:100:1 atd.):

Weights:
     0 (8, 100)
     1 (100, 1)
Biases:
     0 (100,)
     1 (1,)

18. Změna počtu skrytých vrstev a neuronů v těchto vrstvách

Podobně jako u neuronové sítě tvořící základ modelu MLPClassifier můžeme i u neuronové sítě v modelu MLPRegressor měnit jak počet skrytých vrstev, tak i počty neuronů v těchto vrstvách. K tomuto účelu se používá stejný nepovinný parametr hidden_layer_sizes, kterému se předává n-tice obsahující počty neuronů v jednotlivých vrstvách:

# model zalozeny na neuronove siti
from sklearn.neural_network import MLPRegressor
 
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
 
# nacteni datove sady
housings = fetch_california_housing()
 
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
 
# ceny bloku
targets = housings["target"]
 
# X je matice, y je vektor
X = data
y = targets
 
# rozdeleni dat na treninkovou a testovaci mnozinu
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)
 
neurons = 1000
 
# konstrukce modelu
nn = MLPRegressor(max_iter=5000, hidden_layer_sizes = (neurons, neurons, ))
 
# trénink modelu
nn.fit(X_train, y_train)
 
# predikce modelu
y_pred = nn.predict(X_test)
 
# chyba predikce
print("Mean squared error: %.2f" % mean_squared_error(y_test, y_pred))
 
# 1 = nejlepší predikce modelu
print("Coefficient of determination: %.2f" % r2_score(y_test, y_pred))
 
print(f"Features: {nn.n_features_in_}")
print(f"Layers:   {nn.n_layers_}")
print(f"Outputs:  {nn.n_outputs_}")
print("Weights:")
 
for layer, weights in enumerate(nn.coefs_):
    print("\t", layer, weights.shape)

Na výsledky nyní budeme čekat delší dobu, a to kvůli pomalejšímu tréninku neuronové sítě:

CS24 tip temata

Mean squared error: 0.65
Coefficient of determination: 0.51
Features: 8
Layers:   4
Outputs:  1
Weights:
         0 (8, 1000)
         1 (1000, 1000)
         2 (1000, 1)
Biases:
         0 (1000,)
         1 (1000,)
         2 (1,)

19. Repositář s demonstračními příklady

Všechny demonstrační příklady využívající knihovnu Scikit-learn lze nalézt v repositáři https://github.com/tisnik/most-popular-python-libs. Následují odkazy na jednotlivé příklady i na (Jupyter) diáře s postupem výpočtů a analýz:

# Příklad Stručný popis Adresa příkladu
1 01_show_matrix.py kooperace mezi knihovnami Matplotlib a NumPy: vizualizace obsahu 2D matice https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/01_show_ma­trix.py
2 02_get_digits.py datová množina obsahující naskenované ručně napsané číslice https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/02_get_di­gits.py
3 03_get_features.py další atributy datové množiny, které použijeme při trénování https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/03_get_fe­atures.py
4 04_get_images.py přečtení a následné vykreslení jednotlivých ručně nakreslených číslic https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/04_get_i­mages.py
5 05_show_grayscale_matrix.py odstranění umělé aplikované barvové palety (obrázky ve stupních šedi) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/05_show_gra­yscale_matrix.py
6 06_grayscale_images.py vykreslení ručně nakreslených číslic ve formě obrázků ve stupních šedi https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/06_gra­yscale_images.py
7 07_multiplot.py rozdělení plochy grafu do oblastí; vykreslení více obrázků do jediného grafu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/07_mul­tiplot.py
8 08_model_preperation1.py obrázky s jejich ohodnocením https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/08_mo­del_preperation1.py
9 09_training_set.py příprava dat pro trénink https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/09_tra­ining_set.py
10 10_classification.py klasifikace obrázků https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/10_clas­sification.py
11 11_results.py vykreslení obrázků společně s jejich klasifikací https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/11_results.py
12 12_change_training_set.py změna poměru rozdělení dat na tréninkovou a testovací množinu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/12_chan­ge_training_set.py
       
13 13_blobs.py použití funkce make_blobs pro vygenerování sady bodů v rovině sdružených do oblastí https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/13_blobs.py
14 14_swap_coords.py úprava předchozího příkladu: prohození souřadnic na osách https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/14_swap_co­ords.py
15 15_blobs_scatter_plot.py základní podoba bodového diagramu (scatter plot) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/15_blob­s_scatter_plot.py
16 16_blobs_scatter_plot.py úprava bodového diagramu při zobrazení většího množství bodů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/16_blob­s_scatter_plot.py
17 17_colorized_blobs.py obarvení bodů podle oblastí https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/17_co­lorized_blobs.py
18 18_k-means.py základní použití algoritmu K-means pro clustering https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/18_k-means.py
19 19_combination.py zobrazení centroidů společně s původními body https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/19_com­bination.py
20 20_combinations.py vizualizace clusteringu původní množiny bodů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/20_com­binations.py
21 21_other_settings.py vizualizace clusteringu původní množiny bodů pro odlišnou množinu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/21_ot­her_settings.py
22 22_random_points.py clustering pro náhodná data https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/22_ran­dom_points.py
       
23 23_circles.py pseudonáhodné rozmístění bodů do kružnic, menší náhodnost výsledku https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/23_circles.py
24 24_more_noise_circles.py pseudonáhodné rozmístění bodů do kružnic, větší náhodnost výsledku https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/24_mo­re_noise_circles.py
25 25_moons.py pseudonáhodné rozmístění bodů do tvaru dvou půlměsíců, menší náhodnost https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/25_moons.py
26 26_more_noisy_moons.py pseudonáhodné rozmístění bodů do tvaru dvou půlměsíců, větší náhodnost https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/26_mo­re_noisy_moons.py
27 27_circles_kmeans.py výsledek clusteringu provedeného algoritmem K-means na „kružnice“ https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/27_cir­cles_kmeans.py
28 28_moons_kmeans.py výsledek clusteringu provedeného algoritmem K-means na „půlměsíce“ https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/28_mo­ons_kmeans.py
29 29_blobs_spectral_clustering.py spectral clustering pro body rozmístěné pomocí make_blobs https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/29_blob­s_spectral_clustering.py
30 30_circles_spectral_clustering.py spectral clustering pro body rozmístěné do kružnic https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/30_cir­cles_spectral_clustering.py
31 31_moons_spectral_clustering.py spectral clustering pro body rozmístěné do půlměsíců https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/31_mo­ons_spectral_clustering.py
32 32_moons_spectral_clustering_limits.py vyhledání limitů algoritmu spectral clustering https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/32_mo­ons_spectral_clustering_li­mits.py
       
33 33_particles_load.py načtení souřadnic částic uložených v souboru formátu CSV https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/33_par­ticles_load.py
       
34 34_lorenz_attractor.py zobrazení Lorenzova atraktoru formou bodů propojených úsečkami https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/34_lo­renz_attractor.py
35 35_lorenz_attractor_points.py Lorenzův atraktor vykreslený formou jednotlivých bodů s definovaným stylem zobrazení a velikostí stopy https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/35_lo­renz_attractor_points.py
36 36_blobs_3d.py vygenerování a zobrazení sady bodů v 3D prostoru https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/36_blob­s_3d.py
37 37_spread_blobs_3d.py vygenerování a zobrazení sady bodů v 3D prostoru, odlišné parametry při generování https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/37_spre­ad_blobs_3d.py
38 38_views.py různé pohledy na 3D graf https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/38_views.py
39 39_colorized_3d_blobs.py obarvení bodů v prostoru na základě vstupních dat https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/39_co­lorized_3d_blobs.py
40 40_kmeans_3d_blobs.py shluková analýza v 3D prostoru https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/40_kme­ans_3d_blobs.py
41 41_kmeans_spread_3d_blobs.py shluková analýza v 3D prostoru pro odlišnou množinu bodů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/41_kme­ans_spread_3d_blobs.py
42 42_kmeans_random_3d.py shluková analýza pro body rozmístěné zcela náhodně v omezeném prostoru https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/42_kme­ans_random_3d.py
       
43 43_speed_measurements.py benchmark pro postupně rostoucí počet bodů tvořících shluky https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/43_spe­ed_measurements.py
44 44_speed_measurements.py benchmark pro postupně rostoucí počet bodů rozmístěných náhodně https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/44_spe­ed_measurements.py
45 45_speed_measurements.py benchmark pro stále stejný počet bodů, u jejichž rozmístění v prostoru se používá stále větší směrodatná odchylka https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/45_spe­ed_measurements.py
       
46 46_iris_dataset.py načtení datové kolekce https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/46_i­ris_dataset.py
47 47_iris_description.py metadata o datové kolekci https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/47_i­ris_description.py
48 48_iris_data.py tvar dat – počet záznamů a počet proměnných https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/48_i­ris_data.py
49 49_iris_targets.py jména atributů, vztah mezi numerickou hodnotou atributu a jeho jménem https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/49_i­ris_targets.py
       
50 50_iris_scatter_plot1.py korelační diagram pro dvojici vybraných proměnných https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/50_i­ris_scatter_plot1.py
51 51_iris_scatter_plot2.py příprava pro tvorbu složitějších grafů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/51_i­ris_scatter_plot2.py
52 52_iris_mutliplot.py mřížka obsahující více korelačních diagramů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/52_i­ris_mutliplot.py
       
53 53_iris_histograms.py zobrazení základního histogramu pro data v sadě Iris https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/53_i­ris_histograms.py
54 54_iris_histograms.py úprava histogramu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/54_i­ris_histograms.py
       
55 55_pca.py analýza hlavních komponent (PCA), výsledek zobrazený v 2D grafu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/55_pca.py
56 56_pca_3d.py analýza hlavních komponent (PCA), výsledek zobrazený v 3D grafu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/56_pca_3d.py
57 57_kmeans.py základní shluková analýza https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/57_kmeans.py
58 58_multiple_kmeans.py větší množství výsledků shlukové analýzy pro různé atributy https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/58_mul­tiple_kmeans.py
59 59_kmeans_errors.py korektní a nekorektní výsledky základní shlukové analýzy https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/59_kme­ans_errors.py
       
60 60_basic_classifier.py aplikace jednoduchého modelu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/60_ba­sic_classifier.py
61 61_changed_model_parameters.py změna parametrů modelu pro zjištění druhů rostil https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/61_chan­ged_model_parameters.py
62 62_different_model.py použití odlišného modelu pro zjištění druhů rostlin https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/62_dif­ferent_model.py
       
63 63_verify_on_whole_data1.py otestování naučeného modelu s využitím tréninkových dat https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/63_ve­rify_on_whole_data1.py
64 64_verify_on_whole_data2.py využití funkce metrics.accuracy_score pro zjištění kvality modelu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/64_ve­rify_on_whole_data2.py
65 65_basic_comparison.py porovnání vlastností různých modelů (prozatím nekorektní řešení) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/65_ba­sic_comparison.py
66 66_training_testing_split1.py rozdělení datové sady na trénovací data a testovací data (základní varianta) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/66_tra­ining_testing_split1.py
67 67_training_testing_split2.py rozdělení datové sady na trénovací data a testovací data (náhodné rozdělení sady) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/67_tra­ining_testing_split2.py
68 68_training_testing_split3.py rozdělení datové sady na trénovací data a testovací data (využití vestavěné funkce) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/68_tra­ining_testing_split3.py
69 69_better_comparison.py vylepšené porovnání vlastností různých modelů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/69_bet­ter_comparison.py
70 70_multiple_runs.py vliv generátoru náhodných čísel na změřené výsledky https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/70_mul­tiple_runs.py
71 71_stable_multiple_runs.py generátor náhodných čísel a použití hodnoty random_state https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/71_sta­ble_multiple_runs.py
       
72 72_housings_dataset.py načtení datové sady California housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/72_hou­sings_dataset.py
73 73_housings_dataset_description.py metainformace o datové sadě California housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/73_hou­sings_dataset_description­.py
74 74_housings_data.py n-rozměrné pole s atributy jednotlivých domů/bloků https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/74_hou­sings_data.py
75 75_housings_targets.py jména atributů, ceny domů atd. https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/75_hou­sings_targets.py
76 76_housings_scatter_plot.py korelační diagram pro dvojici vybraných proměnných https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/76_hou­sings_scatter_plot.py
77 77_housings_mutliplot.py korelační diagram pro všechny kombinace dvojic proměnných https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/77_hou­sings_mutliplot.py
78 78_scatter.py dvourozměrné hodnoty reprezentované jako dvojice atributů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/78_scatter.py
79 79_linear_regression_gen_data.py model LinearRegression nad uměle vytvořenými daty https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/79_li­near_regression_gen_data.py
80 80_linear_regression_predictions.py predikce modelu provádějícího lineární regresi https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/80_li­near_regression_prediction­s.py
81 81_linear_regression_random_data.py chování modelu pro zcela náhodná data https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/81_li­near_regression_random_da­ta.py
82 82_linear_regression_housings.py model LinearRegression pro datovou sadu California housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/82_li­near_regression_housings.py
83 83_polynomial_regression_gen_data.py polynomiální regrese (základní příklad) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/83_po­lynomial_regression_gen_da­ta.py
84 84_polynomial_regression_housings.py polynomiální regrese a datová sada California housings, první příklad https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/84_po­lynomial_regression_housin­gs.py
85 85_polynomial_regression_housings2.py polynomiální regrese a datová sada California housings, druhý příklad https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/85_po­lynomial_regression_housin­gs2.py
86 86_polynomial_regression_housings3.py polynomiální regrese a datová sada California housings, třetí příklad https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/86_po­lynomial_regression_housin­gs3.py
87 87_linear_regression_errors.py výpočet chyby a skóre modelu lineární regrese https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/87_li­near_regression_errors.py
88 88_linear_regression_non_linear_data.py lineární regrese nad nelineárními daty https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/88_li­near_regression_non_linear_da­ta.py
89 89_polynomial_regression_error.py https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/89_po­lynomial_regression_error­.py
       
90 90_housings_prediction1.py regresní analýza nad daty California housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/90_hou­sings_prediction1.py
91 91_housings_prediction2.py korektní natrénování modelu pro regresi https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/91_hou­sings_prediction2.py
92 92_housings_prediction3.py omezení množství atributů (proměnných), na kterých je model natrénován https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/92_hou­sings_prediction3.py
93 93_housings_prediction_errors1.py chybně natrénovaný model při náhodné volbě dat https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/93_hou­sings_prediction_errors1.py
94 94_housings_prediction_errors2.py omezení atributů + chybně natrénovaný model https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/94_hou­sings_prediction_errors2.py
95 95_housings_histograms.py histogramy pro jednotlivé atributy (proměnné) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/95_hou­sings_histograms.py
96 96_housings_statistic.py statistické údaje pro jednotlivé atributy (proměnné) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/96_hou­sings_statistic.py
97 97_housings_statistic_normalized.py statistické údaje získané po normalizaci https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/97_hou­sings_statistic_normalized­.py
       
98 98_k_fold_help.py zobrazení nápovědy ke třídě s realizací k-foldingu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/98_k_fol­d_help.py
99 99_k_fold_old.py původní (nepodporovaná) varianta provedení k-foldingu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/99_k_fol­d_old.py
100 100_k_fold1.py interní chování algoritmu k-foldingu (základní parametry) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/100_k_fol­d1.py
101 101_k_fold2.py interní chování algoritmu k-foldingu (odlišné parametry) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/101_k_fol­d2.py
102 102_k_fold_selection.py k-folding a výběr dat pro otestování modelů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/102_k_fol­d_selection.py
103 103_average_score.py realizace výpočtu průměrného skóre pro otestování modelů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/103_a­verage_score.py
104 104_hyperparams_score.py změna hyperparametrů s výpočtem průměrného skóre (tabulka) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/104_hy­perparams_score.py
105 105_hyperparams_score_plot.py změna hyperparametrů s výpočtem průměrného skóre (graf) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/105_hy­perparams_score_plot.py
106 106_model_selection.py výběr nejlepšího modelu s využitím k-foldingu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/106_mo­del_selection.py
107 107_features_selection_basic.py výběr atributů (proměnných) pro trénink modelu (základní varianta) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/107_fe­atures_selection_basic.py
108 108_features_selection_iris.py výběr atributů (proměnných) pro trénink modelu (datová sada Iris) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/108_fe­atures_selection_iris.py
109 109_features_selection_houses.py výběr atributů (proměnných) pro trénink modelu (datová sada California Housings) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/109_fe­atures_selection_houses.py
110 110_best_features_selection_houses.py získání nejlepší sady atributů (proměnných) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/110_bes­t_features_selection_houses­.py
111 111_features_selection_graphical.py výběr atributů (proměnných) pro trénink modelu (datová sada Iris), grafický výstup https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/111_fe­atures_selection_graphical­.py
       
112 112_simplest_linear_regression.py lineární regrese bodů ležících v rovině https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/112_sim­plest_linear_regression.py
113 113_linear_regression_no_intercept.py lineární regrese při vynucení w0=0 pro obecná data https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/113_li­near_regression_no_intercep­t.py
114 114_linear_regression_from0_0.py lineární regrese při vynucení w0=0 v případě, že vstupní body obsahují počátek souřadného systému https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/114_li­near_regression_from0_0.py
115 115_linear_regression_multiple_y.py model předpovídající pro každou vstupní hodnotu dvě výstupní hodnoty (odpovědi) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/115_li­near_regression_multiple_y­.py
116 116_grid_operations.py konstrukce matice obsahující souřadnice bodů v mřížce https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/116_grid_o­perations.py
117 117_linear_regression_multiple_x.py proložení bodů v prostoru rovinou https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/117_li­near_regression_multiple_x­.py
118 118_linear_regression_multiple_x.py proložení bodů s náhodnou výškou rovinou https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/118_li­near_regression_multiple_x­.py
119 119_linear_regression_mul­tiple_x_and_y.py proložení dvou sad bodů dvojicí rovin https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/119_li­near_regression_multiple_x_an­d_y.py
120 120_linear_regression_mul­tiple_x_and_y.py proložení dvou sad bodů dvojicí rovin https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/120_li­near_regression_multiple_x_an­d_y.py
121 121_linear_regression_poly.py základní polynomická regrese https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/121_li­near_regression_poly.py
122 122_linear_regression_poly_mul­tiple_x.py polynomická regrese a body v prostoru, první příklad https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/122_li­near_regression_poly_multi­ple_x.py
123 123_linear_regression_poly_mul­tiple_x.py polynomická regrese a body v prostoru, druhý příklad https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/123_li­near_regression_poly_multi­ple_x.py
       
124 124_iris_set_statistic.py získání statistických informací o datové sadě Iris https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/124_i­ris_set_statistic.py
125 125_california_housings_statistic.py získání statistických informací o datové sadě California Housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/125_ca­lifornia_housings_statistic­.py
126 126_variance_threshold1.py výběr atributů pro trénink modelu pomocí VarianceThreshold https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/126_va­riance_threshold1.py
127 127_variance_threshold2.py výběr atributů pro trénink modelu pomocí VarianceThreshold https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/127_va­riance_threshold2.py
128 128_variance_threshold3.py výběr atributů pro trénink modelu pomocí VarianceThreshold https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/128_va­riance_threshold3.py
129 129_select_best_iris.py výběr nejvhodnějších atributů pro datovou sadu Iris https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/129_se­lect_best_iris.py
130 130_select_best_housings.py výběr nejvhodnějších atributů pro datovou sadu California Housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/130_se­lect_best_housings.py
131 131_select_k_best_housings.py výběr K nejvhodnějších atributů pro datovou sadu California Housings https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/131_se­lect_k_best_housings.py
132 132_select_from_model.py výběr atributů na základě k tomu určeného modelu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/132_se­lect_from_model.py
133 133_cross_validation1.py křížová validace po výběru (filtraci) modelů (datová sada Iris) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/133_cros­s_validation1.py
134 134_cross_validation2.py křížová validace po výběru (filtraci) modelů (datová sada California Housings) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/134_cros­s_validation2.py
135 135_cross_validation3.py křížová validace po výběru (filtraci) modelů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/135_cros­s_validation3.py
       
136 136_mlp_classifier01.py použití neuronové sítě pro klasifikaci https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/136_mlp_clas­sifier01.py
137 137_mlp_classifier02.py výpočet úspěšnosti modelu založeného na neuronové síti https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/137_mlp_clas­sifier02.py
138 138_mlp_classifier03.py konfigurace vrstev neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/138_mlp_clas­sifier03.py
139 139_mlp_classifier04.py proměnný počet neuronů ve vrstvách neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/139_mlp_clas­sifier04.py
140 140_mlp_classifier05.py proměnný počet neuronů ve více vrstvách neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/140_mlp_clas­sifier05.py
       
141 141_mlp_regression1.py použití neuronové sítě pro regresi https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/141_mlp_re­gression1.py
142 142_mlp_regression2.py modifikace parametrů neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/142_mlp_re­gression2.py

V repositáři nalezneme taktéž projektový soubor a Jupyter Notebook s vysvětlením, jak lze modely využít pro rozpoznávání obsahu rastrových obrázků:

# Příklad Stručný popis Adresa příkladu
1 pyproject.toml projektový soubor (pro PDM) se všemi závislostmi https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/py­project.toml
       
2 pdm.lock lock soubor s konkrétními verzemi všech přímých i tranzitivních závislostí https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/pdm.lock
       
3 Rozpoznání_obrazu_scikit-learn.ipynb Jupyter notebook s celým postupem https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/Roz­poznání_obrazu_scikit-learn.ipynb
       
4 particle_life.py emergence: příklad vzniku struktury https://github.com/tisnik/most-popular-python-libs/blob/master/particles/par­ticle_life.py

20. Odkazy na Internetu

  1. Shluková analýza (clustering) a knihovna Scikit-learn
    https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn/
  2. Shluková analýza (clustering) a knihovna Scikit-learn (2)
    https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn-2/
  3. Shluková analýza (clustering) a knihovna Scikit-learn (z plochy do 3D prostoru)
    https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn-z-plochy-do-3d-prostoru/
  4. Rozpoznávání obrázků knihovnou Scikit-learn: první kroky
    https://www.root.cz/clanky/roz­poznavani-obrazku-knihovnou-scikit-learn-prvni-kroky/
  5. scikit-learn: Machine Learning in Python
    https://scikit-learn.org/stable/index.html
  6. Sklearn-pandas
    https://github.com/scikit-learn-contrib/sklearn-pandas
  7. sklearn-xarray
    https://github.com/phausamann/sklearn-xarray/
  8. Clustering
    https://scikit-learn.org/stable/modules/clus­tering.html
  9. Cluster analysis (Wikipedia)
    https://en.wikipedia.org/wi­ki/Cluster_analysis
  10. Shluková analýza (Wikipedia)
    https://cs.wikipedia.org/wi­ki/Shlukov%C3%A1_anal%C3%BDza
  11. K-means
    https://cs.wikipedia.org/wiki/K-means
  12. k-means clustering
    https://en.wikipedia.org/wiki/K-means_clustering
  13. Spectral clustering
    https://en.wikipedia.org/wi­ki/Spectral_clustering
  14. Emergence
    https://cs.wikipedia.org/wi­ki/Emergence
  15. Particle Life: Vivid structures from rudimentary rules
    https://particle-life.com/
  16. Hertzsprungův–Russellův diagram
    https://cs.wikipedia.org/wi­ki/Hertzsprung%C5%AFv%E2%80%93Rus­sell%C5%AFv_diagram
  17. Using Machine Learning in an HR Diagram
    https://cocalc.com/share/pu­blic_paths/08b6e03583cbdef3cdb98­13a54ec68ff773c747f
  18. Gaia H-R diagrams: Querying Gaia data for one million nearby stars
    https://vlas.dev/post/gaia-dr2-hrd/
  19. The Hertzsprung–Russell diagram
    https://scipython.com/book2/chapter-9-data-analysis-with-pandas/problems/p92/the-hertzsprung-russell-diagram/
  20. Animated Hertzsprung-Russell Diagram with 119,614 datapoints
    https://github.com/zonination/h-r-diagram
  21. Neuraxle Pipelines
    https://github.com/Neuraxio/Neuraxle
  22. scikit-learn: Getting Started
    https://scikit-learn.org/stable/getting_started.html
  23. Support Vector Machines
    https://scikit-learn.org/stable/modules/svm.html
  24. Use Deep Learning to Detect Programming Languages
    http://searene.me/2017/11/26/use-neural-networks-to-detect-programming-languages/
  25. Natural-language processing
    https://en.wikipedia.org/wiki/Natural-language_processing
  26. THE MNIST DATABASE of handwritten digits
    http://yann.lecun.com/exdb/mnist/
  27. MNIST database (Wikipedia)
    https://en.wikipedia.org/wi­ki/MNIST_database
  28. MNIST For ML Beginners
    https://www.tensorflow.or­g/get_started/mnist/begin­ners
  29. Stránka projektu Torch
    http://torch.ch/
  30. Torch: Serialization
    https://github.com/torch/tor­ch7/blob/master/doc/seria­lization.md
  31. Torch: modul image
    https://github.com/torch/i­mage/blob/master/README.md
  32. Data pro neuronové sítě
    http://archive.ics.uci.edu/ml/in­dex.php
  33. Torch na GitHubu (několik repositářů)
    https://github.com/torch
  34. Torch (machine learning), Wikipedia
    https://en.wikipedia.org/wi­ki/Torch_%28machine_learnin­g%29
  35. Torch Package Reference Manual
    https://github.com/torch/tor­ch7/blob/master/README.md
  36. Torch Cheatsheet
    https://github.com/torch/tor­ch7/wiki/Cheatsheet
  37. Neural network containres (Torch)
    https://github.com/torch/nn/blob/mas­ter/doc/containers.md
  38. Simple layers
    https://github.com/torch/nn/blob/mas­ter/doc/simple.md#nn.Line­ar
  39. Transfer Function Layers
    https://github.com/torch/nn/blob/mas­ter/doc/transfer.md#nn.tran­sfer.dok
  40. Feedforward neural network
    https://en.wikipedia.org/wi­ki/Feedforward_neural_net­work
  41. Biologické algoritmy (4) – Neuronové sítě
    https://www.root.cz/clanky/biologicke-algoritmy-4-neuronove-site/
  42. Biologické algoritmy (5) – Neuronové sítě
    https://www.root.cz/clanky/biologicke-algoritmy-5-neuronove-site/
  43. Umělá neuronová síť (Wikipedia)
    https://cs.wikipedia.org/wi­ki/Um%C4%9Bl%C3%A1_neuronov%C3%A1_s%C3%AD%C5%A5
  44. PyTorch
    http://pytorch.org/
  45. JupyterLite na PyPi
    https://pypi.org/project/jupyterlite/
  46. JupyterLite na GitHubu
    https://github.com/jupyter­lite/jupyterlite
  47. Dokumentace k projektu JupyterLite
    https://github.com/jupyter­lite/jupyterlite
  48. Matplotlib Home Page
    http://matplotlib.org/
  49. Matplotlib (Wikipedia)
    https://en.wikipedia.org/wi­ki/Matplotlib
  50. Popis barvových map modulu matplotlib.cm
    https://gist.github.com/en­dolith/2719900#id7
  51. Ukázky (palety) barvových map modulu matplotlib.cm
    http://matplotlib.org/exam­ples/color/colormaps_refe­rence.html
  52. Galerie grafů vytvořených v Matplotlibu
    https://matplotlib.org/3.2.1/gallery/
  53. 3D rendering
    https://en.wikipedia.org/wi­ki/3D_rendering
  54. 3D computer graphics
    https://en.wikipedia.org/wi­ki/3D_computer_graphics
  55. Primary 3D view planes
    https://matplotlib.org/sta­ble/gallery/mplot3d/view_pla­nes_3d.html
  56. Getting started in scikit-learn with the famous iris dataset
    https://www.youtube.com/wat­ch?v=hd1W4CyPX58
  57. Training a machine learning model with scikit-learn
    https://www.youtube.com/wat­ch?v=RlQuVL6-qe8
  58. Iris (plant)
    https://en.wikipedia.org/wi­ki/Iris_(plant)
  59. Kosatec
    https://cs.wikipedia.org/wiki/Kosatec
  60. Iris setosa
    https://en.wikipedia.org/wi­ki/Iris_setosa
  61. Iris versicolor
    https://en.wikipedia.org/wi­ki/Iris_versicolor
  62. Iris virginica
    https://en.wikipedia.org/wi­ki/Iris_virginica
  63. Druh
    https://cs.wikipedia.org/wiki/Druh
  64. Iris subg. Limniris
    https://en.wikipedia.org/wi­ki/Iris_subg._Limniris
  65. Iris Dataset Classification with Python: A Tutorial
    https://www.pycodemates.com/2022/05/i­ris-dataset-classification-with-python.html
  66. Iris flower data set
    https://en.wikipedia.org/wi­ki/Iris_flower_data_set
  67. List of datasets for machine-learning research
    https://en.wikipedia.org/wi­ki/List_of_datasets_for_machi­ne-learning_research
  68. Analýza hlavních komponent
    https://cs.wikipedia.org/wi­ki/Anal%C3%BDza_hlavn%C3%AD­ch_komponent
  69. Principal component analysis
    https://en.wikipedia.org/wi­ki/Principal_component_ana­lysis
  70. Scikit-learn Crash Course – Machine Learning Library for Python
    https://www.youtube.com/wat­ch?v=0B5eIE_1vpU
  71. calm-notebooks
    https://github.com/koaning/calm-notebooks
  72. Should you teach Python or R for data science?
    https://www.dataschool.io/python-or-r-for-data-science/
  73. nbviewer: A simple way to share Jupyter Notebooks
    https://nbviewer.org/
  74. AI vs Machine Learning (Youtube)
    https://www.youtube.com/wat­ch?v=4RixMPF4×is
  75. Machine Learning | What Is Machine Learning? | Introduction To Machine Learning | 2024 | Simplilearn (Youtube)
    https://www.youtube.com/wat­ch?v=ukzFI9rgwfU
  76. A Gentle Introduction to Machine Learning (Youtube)
    https://www.youtube.com/wat­ch?v=Gv9_4yMHFhI
  77. Machine Learning vs Deep Learning
    https://www.youtube.com/wat­ch?v=q6kJ71tEYqM
  78. Umělá inteligence (slajdy)
    https://slideplayer.cz/sli­de/12119218/
  79. Úvod do umělé inteligence
    https://slideplayer.cz/slide/2505525/
  80. Umělá inteligence I / Artificial Intelligence I
    https://ktiml.mff.cuni.cz/~bartak/ui/
  81. Matplotlib vs. seaborn vs. Plotly vs. MATLAB vs. ggplot2 vs. pandas
    https://ritza.co/articles/matplotlib-vs-seaborn-vs-plotly-vs-MATLAB-vs-ggplot2-vs-pandas/
  82. Matplotlib, Seaborn or Plotnine?
    https://www.reddit.com/r/da­tascience/comments/jvrqxt/mat­plotlib_seaborn_or_plotni­ne/
  83. @Rabeez: Rabeez/plotting_comparison.ipynb
    https://gist.github.com/Ra­beez/ffc0b59d4a41e20fa8d94­4c44a96adbc
  84. Matplotlib, Seaborn, Plotly and Plotnine Comparison
    https://python.plainenglish­.io/matplotlib-seaborn-plotly-and-plotnine-comparison-baf2db5a9c40
  85. Data Visualization 101: How to Choose a Python Plotting Library
    https://towardsdatascience.com/data-visualization-101-how-to-choose-a-python-plotting-library-853460a08a8a
  86. Data science in Python: pandas, seaborn, scikit-learn
    https://www.youtube.com/wat­ch?v=3ZWuPVWq7p4
  87. 7.2. Real world datasets
    https://scikit-learn.org/stable/datasets/re­al_world.html#california-housing-dataset
  88. 7.2.7. California Housing dataset
    https://scikit-learn.org/stable/datasets/re­al_world.html#california-housing-dataset
  89. Comprehensive Guide to Classification Models in Scikit-Learn
    https://www.geeksforgeeks­.org/comprehensive-guide-to-classification-models-in-scikit-learn/
  90. Tidy Data Visualization: ggplot2 vs seaborn
    https://blog.tidy-intelligence.com/posts/ggplot2-vs-seaborn/
  91. seaborn: statistical data visualization
    https://seaborn.pydata.org/
  92. Linear regression (Wikipedia)
    https://en.wikipedia.org/wi­ki/Linear_regression
  93. Lineární regrese (Wikipedia)
    https://cs.wikipedia.org/wi­ki/Line%C3%A1rn%C3%AD_regre­se
  94. Iris Flower Classification with MLP Classifier
    https://www.metriccoders.com/post/iris-flower-classification-with-mlp-classifier

Autor článku

Vystudoval VUT FIT a v současné době pracuje na projektech vytvářených v jazycích Python a Go.