Využití knihovny scikit-learn pro zpracování a analýzu přirozeného jazyka (NLP), 2.část

21. 11. 2024
Doba čtení: 60 minut

Sdílet

 Autor: Depositphotos
Dnes si vysvětlíme algoritmy pro vektorizaci jazykového korpusu, což je proces, při kterém se z jednotlivých textových dokumentů (každý dokument je představován řetězcem) konstruuje matice s numerickými hodnotami.

Obsah

1. Využití knihovny scikit-learn pro zpracování a analýzu přirozeného jazyka (NLP), 2.část

2. Vektorizace sady textů (korpusu) s využitím třídy CountVectorizer

3. Zkonstruovaná tabulka (slovník) pro zpětný převod indexů na slova

4. Význam parametru cut off pro vektorizaci

5. Význam parametru max_df pro vektorizaci

6. Zpětný převod matice s frekvencí slov na slova

7. Odstranění stopslov v průběhu vektorizace

8. Korektně provedený zpětný převod vektorů na dokumenty

9. Tf-idf: relevance a specifičnost jednotlivých slov vztažená k aktuálnímu dokumentu i k celému korpusu

10. Základní vlastnosti výpočtu relevance slov

11. Další příklady výpočtu tf-idf

12. Realizace výpočtu matice s relevancí jednotlivých slov

13. Vliv většího množství dokumentů se stejnými slovy v korpusu na vypočtenou relevanci slov

14. Přímé využití třídy TfidfVectorizer

15. Nalezení textu, který se nejvíce blíží hledanému vzorku

16. Realizace algoritmu pro nalezení nejpodobnější věty

17. Úskalí algoritmu pro hledání podobných textů

18. Vektorizovaný text a neuronové sítě

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

20. Odkazy na Internetu

1. Využití knihovny scikit-learn pro zpracování a analýzu přirozeného jazyka (NLP), 2.část

Na úvodní článek o využití knihovny scikit-learn pro zpracování přirozeného jazyka (Natural Language Processing – NLP) dnes navážeme. Vysvětlíme si algoritmy pro vektorizaci jazykového korpusu, což je proces, při němž se z jednotlivých textových dokumentů (každý dokument je představován řetězcem) konstruuje matice s numerickými hodnotami. Tyto hodnoty nějakým způsobem reprezentují původní korpus, resp. přesněji řečeno jeho vybrané typické znaky. Navíc tato matice může v sobě mít zakódovány i další vlastnosti, například specifičnost jednotlivých slov v kontextu celého korpusu atd. Tato matice se používá jak pro trénink a validaci modelů (včetně modelů založených na neuronové síti), tak i pro jednodušší operace – nalezení nejbližšího textu (text similarity). I s tímto algoritmem se dnes ve stručnosti seznámíme.

2. Vektorizace sady textů (korpusu) s využitím třídy CountVectorizer

Prvním úkolem, který je nutné provést ještě předtím, než (nějakým způsobem) natrénujeme a následně zvalidujeme model, je převod sady textů (ty označujeme jako korpus) do numerické podoby, konkrétně do 2D matice. Nejjednodušším postupem, který se v této oblasti používá, je konstrukce 2D matice, která má počet řádků odpovídající počtu vstupních dokumentů a počet sloupců odpovídá počtu všech unikátních slov ze všech vstupních dokumentů (tedy z celého korpusu). Do takové matice můžeme zapsat počty jednotlivých slov ve vstupních dokumentech – což ovšem znamená, že ztratíme kontextovou informaci o tom, jaká je sekvence slov v původních dokumentech. Výše uvedený algoritmus je v knihovně scikit-learn realizován třídou CountVectorizer. Ukažme si její použití při vektorizaci korpusu, v němž je pouze šest vět:

# Vektorizace sady textů (korpusu)
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)
 
# získat vektor z 2D pole
flattened = as_array.flatten()
 
# unikátní prvky a jejich frekvence
unique, counts = np.unique(flattened, return_counts=True)
 
print("Word count statistic:")
print(np.asarray((unique, counts)).T)

Samotná vektorizace je realizována následovně:

# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)

Výsledkem vektorizace je řídká matice (sparse matrix), která by měla vypadat takto:

  (0, 13)       1
  (0, 0)        2
  (0, 2)        2
  (0, 17)       1
  (0, 19)       1
  (1, 0)        1
  (1, 2)        1
  (1, 8)        1
  (1, 11)       1
  (1, 22)       1
  (1, 10)       1
  (1, 4)        1
  (2, 0)        2
  (2, 2)        1
  (2, 15)       1
  (2, 7)        1
  (2, 23)       1
  (2, 18)       1
  (3, 23)       1
  (3, 18)       1
  (3, 20)       1
  (3, 21)       1
  (3, 12)       1
  (4, 22)       1
  (4, 18)       1
  (4, 21)       1
  (4, 12)       1
  (4, 9)        1
  (4, 3)        1
  (4, 1)        1
  (4, 6)        1
  (5, 2)        1
  (5, 18)       1
  (5, 1)        1
  (5, 6)        1
  (5, 16)       1
  (5, 14)       1
  (5, 24)       1
  (5, 5)        1

Řídkou matici si můžeme nechat převést na běžnou matici pomocí metody toarray:

# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)

Výsledná matice:

[[2 0 2 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0]
 [1 0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0]
 [2 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 1 0]
 [0 1 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0 0 1 1 0 0]
 [0 1 1 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1]]

Taktéž si můžeme nechat zobrazit statistické informace – frekvence jednotlivých prvků v celé matici, která obsahuje 25×6=150 prvků:

# získat vektor z 2D pole
flattened = as_array.flatten()
 
# unikátní prvky a jejich frekvence
unique, counts = np.unique(flattened, return_counts=True)
 
print("Word count statistic:")
print(np.asarray((unique, counts)).T)

Ze statistiky je patrné, že matice skutečně obsahuje mnoho nulových prvků a proto je její reprezentace řídkou maticí užitečná (první sloupec zobrazuje hodnotu prvku, druhý počet prvků s touto hodnotou):

Word count statistic:
[[  0 111]
 [  1  36]
 [  2   3]]

3. Zkonstruovaná tabulka (slovník) pro zpětný převod indexů na slova

Ve skutečnosti není výsledkem vektorizace pouze tabulka s četnostmi jednotlivých slov, protože pouze z této informace bychom nezjistili, o jaká konkrétní slova se jedná. Musíme mít k dispozici i slovník, z něhož bude patrné, že slovo na první pozici (první sloupec matice) je například „ahoj“ a druhé slovo (druhý sloupec matice) je „zeď“. I k těmto údajům ve skutečnosti máme přístup, protože z objektu představujícího výsledek vektorizace lze metodou get_feature_names_out přečíst jména takzvaných atributů (features), což je onen požadovaný slovník:

# Tabulka pro zpětný převod indexů na slova
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
print("Feature names count:", len(feature_names))
print()
 
# tabulka indexů slov a vlastních slov
print("Index Feature")
for i, feature_name in enumerate(feature_names):
    print(f"{i:2}    {feature_name}")
 
print()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)

V našem konkrétním případě bude slovník obsahovat 25 slov získaných ze všech šesti dokumentů (vět) korpusu:

Feature names count: 25
 
Index Feature
 0    an
 1    and
 2    apple
 3    are
 4    away
 5    be
 6    blue
 7    compare
 8    day
 9    docs
10    doctor
11    keeps
12    learn
13    like
14    logo
15    never
16    new
17    or
18    orange
19    pie
20    prefer
21    scikit
22    the
23    to
24    will

4. Význam parametru cut off pro vektorizaci

Připomeňme si, že při vektorizaci se konstruktoru CountVectorizer předával i parametr min_df, které je ovšem znám spíše pod označením cut off:

# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)

Tímto parametrem se určuje, jaký minimální počet výskytů musí nějaké slovo mít, aby se uložilo do slovníku. Výchozí hodnotou je 1, tj. do slovníku je uloženo jakékoli nalezené slovo. Ovšem pokud například nastavíme tento parametr na 3, bude slovník menší – bude totiž obsahovat pouze slova, která byla nalezena minimálně třikrát atd. Ukažme si vliv tohoto parametru jak na velikost slovníku, tak i na rozměry matice vytvořené vektorizací:

# Tabulka pro zpětný převod indexů na slova, role parametru cut off.
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
for cut_off in range(1, 7):
    print("Cut off set to:", cut_off)
    print()
    # provedení vektorizace korpusu
    vectorizer = CountVectorizer(min_df=cut_off)
    vectorized = vectorizer.fit_transform(corpus)
 
    # slova pro dekódování vah
    feature_names = vectorizer.get_feature_names_out()
    print("Feature names count:", len(feature_names))
    print()
 
    # tabulka indexů slov a vlastních slov
    print("Index Feature")
    for i, feature_name in enumerate(feature_names):
        print(f"{i:2}    {feature_name}")
 
    print()
 
    # převod na běžnou matici
    as_array = vectorized.toarray()
 
    # zobrazení výsledku v novém formátu
    print(as_array)
    print("-" * 100)

Povšimněte si, jak se slovník i matice zmenšuje společně s rostoucí hodnotou cut off:

Cut off set to: 1
 
Feature names count: 25
 
Index Feature
 0    an
 1    and
 2    apple
 3    are
 4    away
 5    be
 6    blue
 7    compare
 8    day
 9    docs
10    doctor
11    keeps
12    learn
13    like
14    logo
15    never
16    new
17    or
18    orange
19    pie
20    prefer
21    scikit
22    the
23    to
24    will
 
[[2 0 2 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0]
 [1 0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0]
 [2 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 1 0]
 [0 1 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0 0 1 1 0 0]
 [0 1 1 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1]]
----------------------------------------------------------------------------------------------------
Cut off set to: 2
 
Feature names count: 9
 
Index Feature
 0    an
 1    and
 2    apple
 3    blue
 4    learn
 5    orange
 6    scikit
 7    the
 8    to
 
[[2 0 2 0 0 0 0 0 0]
 [1 0 1 0 0 0 0 1 0]
 [2 0 1 0 0 1 0 0 1]
 [0 0 0 0 1 1 1 0 1]
 [0 1 0 1 1 1 1 1 0]
 [0 1 1 1 0 1 0 0 0]]
----------------------------------------------------------------------------------------------------
Cut off set to: 3
 
Feature names count: 3
 
Index Feature
 0    an
 1    apple
 2    orange
 
[[2 2 0]
 [1 1 0]
 [2 1 1]
 [0 0 1]
 [0 0 1]
 [0 1 1]]
----------------------------------------------------------------------------------------------------
Cut off set to: 4
 
Feature names count: 2
 
Index Feature
 0    apple
 1    orange
 
[[2 0]
 [1 0]
 [1 1]
 [0 1]
 [0 1]
 [1 1]]

Pro větší hodnoty cut off se již vyhodí výjimka, protože by slovník byl prázdný a matice tudíž měla 0 sloupců:

----------------------------------------------------------------------------------------------------
Cut off set to: 5
 
Traceback (most recent call last):
  File "/home/ptisnovs/xy/199_cut_off.py", line 20, in <module>
    vectorized = vectorizer.fit_transform(corpus)
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/ptisnovs/.local/lib/python3.11/site-packages/sklearn/base.py", line 1473, in wrapper
    return fit_method(estimator, *args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/ptisnovs/.local/lib/python3.11/site-packages/sklearn/feature_extraction/text.py", line 1385, in fit_transform
    X = self._limit_features(
        ^^^^^^^^^^^^^^^^^^^^^
  File "/home/ptisnovs/.local/lib/python3.11/site-packages/sklearn/feature_extraction/text.py", line 1237, in _limit_features
    raise ValueError(
ValueError: After pruning, no terms remain. Try a lower min_df or a higher max_df.

5. Význam parametru max_df pro vektorizaci

Průběh vektorizace lze ovlivnit i parametrem max df, který má opačný význam, než cut off. Umožňuje nám totiž odstranit ze slovníku ta slova, která mají příliš vysoký výskyt. Taková slova (pravděpodobně) nebudou mít vliv na přesnost naučeného modelu a naopak jejich odstraněním můžeme významně zmenšit velikost výsledné matice. Ukažme si nejdříve, jak se tento parametr předává konstruktoru CountVectorizer:

# Tabulka pro zpětný převod indexů na slova role parametru max_df
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
for max_df in range(1, 4):
    print("max_df set to:", max_df)
    print()
    # provedení vektorizace korpusu
    vectorizer = CountVectorizer(min_df=1, max_df=max_df)
    vectorized = vectorizer.fit_transform(corpus)
 
    # slova pro dekódování vah
    feature_names = vectorizer.get_feature_names_out()
    print("Feature names count:", len(feature_names))
    print()
 
    # tabulka indexů slov a vlastních slov
    print("Index Feature")
    for i, feature_name in enumerate(feature_names):
        print(f"{i:2}    {feature_name}")
 
    print()
 
    # převod na běžnou matici
    as_array = vectorized.toarray()
 
    # zobrazení výsledku v novém formátu
    print(as_array)
    print("-" * 100)

První slovník bude obsahovat pouze šestnáct slov:

----------------------------------------------------------------------------------------------------
max_df set to: 1
 
Feature names count: 16
 
Index Feature
 0    are
 1    away
 2    be
 3    compare
 4    day
 5    docs
 6    doctor
 7    keeps
 8    like
 9    logo
10    never
11    new
12    or
13    pie
14    prefer
15    will
 
[[0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0]
 [0 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0]
 [0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0]
 [1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 1]]

Druhý slovník již bude mít 22 slov (přidáno bylo například frekventované slovo „and“ a taktéž „the“ atd.):

----------------------------------------------------------------------------------------------------
max_df set to: 2
 
Feature names count: 22
 
Index Feature
 0    and
 1    are
 2    away
 3    be
 4    blue
 5    compare
 6    day
 7    docs
 8    doctor
 9    keeps
10    learn
11    like
12    logo
13    never
14    new
15    or
16    pie
17    prefer
18    scikit
19    the
20    to
21    will
 
[[0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0]
 [0 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0]
 [0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0]
 [0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0]
 [1 1 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 1 1 0 0]
 [1 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1]]

A konečně třetí slovník bude mít 23 slov, a to včetně členu „an“:

----------------------------------------------------------------------------------------------------
max_df set to: 3
 
Feature names count: 23
 
Index Feature
 0    an
 1    and
 2    are
 3    away
 4    be
 5    blue
 6    compare
 7    day
 8    docs
 9    doctor
10    keeps
11    learn
12    like
13    logo
14    never
15    new
16    or
17    pie
18    prefer
19    scikit
20    the
21    to
22    will
 
[[2 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0]
 [1 0 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0]
 [2 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0]
 [0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0]
 [0 1 1 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 1 1 0 0]
 [0 1 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1]]
----------------------------------------------------------------------------------------------------
Poznámka: oba parametry ovlivňující vektorizaci lze pochopitelně kombinovat.

6. Zpětný převod matice s frekvencí slov na slova

V případě, že máme k dispozici matici s frekvencí slov (řádky přitom odpovídají původním dokumentům, sloupce pak odpovídají pořadí slova ve slovníku), můžeme se pokusit o realizaci zpětného převodu matice na původní dokumenty. Již nyní ovšem víme, že nezískáme původní věty (dokumenty), ale pouze skupinu slov tvořících původní větu. To by však mohlo pro mnoho účelů dostačovat. Samotný převod je jednoduchý a je založen na detekci těch prvků v matici, které mají nenulovou hodnotu:

# Realizace zpětného převodu na slova
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
print("Feature names count:", len(feature_names))
print()
 
# tabulka indexů slov a vlastních slov
print("Index Feature")
for i, feature_name in enumerate(feature_names):
    print(f"{i:2}    {feature_name}")
 
print()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)
print()
 
 
def array_to_words(feature_names, as_array):
    """Převod matice s frekvencemi slov zpět na slova."""
    return list(
        feature_names[index]
        for index, included in enumerate(as_array[i])
        if included == 1
    )
 
 
# zpětný převod vět
for i in range(len(corpus)):
    print("Original: ", corpus[i])
    print("Vectors:  ", as_array[i])
    print("As words: ", array_to_words(feature_names, as_array))
    print()

Výše uvedená funkce array_to_words sice není napsána korektně (a pokuste se sami zjistit, proč tomu tak je – vysvětlení podáme později), ovšem dokáže z vektoru 25 hodnot, tedy z jednoho řádku tabulky, částečně „zrekonstruovat“ původní věty, resp. slova použitá v těchto větách:

Original:  I'd like an apple or an apple pie
Vectors:   [2 0 2 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0]
As words:  ['like', 'or', 'pie']
 
Original:  An apple a day keeps the doctor away
Vectors:   [1 0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0]
As words:  ['an', 'apple', 'away', 'day', 'doctor', 'keeps', 'the']
 
Original:  Never compare an apple to an orange
Vectors:   [2 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0]
As words:  ['apple', 'compare', 'never', 'orange', 'to']
 
Original:  I prefer scikit-learn to orange
Vectors:   [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 1 0]
As words:  ['learn', 'orange', 'prefer', 'scikit', 'to']
 
Original:  The scikit-learn docs are orange and blue
Vectors:   [0 1 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0 0 1 1 0 0]
As words:  ['and', 'are', 'blue', 'docs', 'learn', 'orange', 'scikit', 'the']
 
Original:  New apple logo will be orange and blue
Vectors:   [0 1 1 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1]
As words:  ['and', 'apple', 'be', 'blue', 'logo', 'new', 'orange', 'will']

7. Odstranění stopslov v průběhu vektorizace

Již minule jsme se v rychlosti zmínili o takzvaných stopslovech neboli anglicky stopwords. Jedná se většinou o slova, která ve větách mají spíše jen gramatický význam, ovšem nenesou příliš mnoho dalších informací. V angličtině se v první řadě jedná o členy, ale může se jednat i o předložky atd. Taková slova většinou můžeme ze slovníku odstranit (resp. je vůbec do slovníku nepřidávat), aniž by to změnilo kvalitu výsledného modelu. Pokusme se tedy tuto operaci provést při vektorizaci našeho malého korpusu složeného ze šesti vět:

# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)

Upravený skript bude vypadat následovně:

# Realizace zpětného převodu na slova, odstranění stopslov
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
print("Feature names count:", len(feature_names))
print()
 
# tabulka indexů slov a vlastních slov
print("Index Feature")
for i, feature_name in enumerate(feature_names):
    print(f"{i:2}    {feature_name}")
 
print()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)
print()
 
 
def array_to_words(feature_names, as_array):
    """Převod matice s frekvencemi slov zpět na slova."""
    return list(
        feature_names[index]
        for index, included in enumerate(as_array[i])
        if included == 1
    )
 
 
# zpětný převod vět
for i in range(len(corpus)):
    print("Original: ", corpus[i])
    print("Vectors:  ", as_array[i])
    print("As words: ", array_to_words(feature_names, as_array))
    print()

Nyní bude slovník menší, protože namísto 25 slov bude obsahovat jen slov šestnáct:

Feature names count: 16
 
Index Feature
 0    apple
 1    away
 2    blue
 3    compare
 4    day
 5    docs
 6    doctor
 7    keeps
 8    learn
 9    like
10    logo
11    new
12    orange
13    pie
14    prefer
15    scikit

Stejně tak se zmenší matice získaná vektorizací:

[[2 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0]
 [1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0]
 [1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0]
 [0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1]
 [0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1]
 [1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0]]

Při obnově původních vět nyní budou pochopitelně všechna stopslova chybět – tuto informaci jsme ztratili při vektorizaci:

Original:  I'd like an apple or an apple pie
Vectors:   [2 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0]
As words:  ['like', 'pie']
 
Original:  An apple a day keeps the doctor away
Vectors:   [1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0]
As words:  ['apple', 'away', 'day', 'doctor', 'keeps']
 
Original:  Never compare an apple to an orange
Vectors:   [1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0]
As words:  ['apple', 'compare', 'orange']
 
Original:  I prefer scikit-learn to orange
Vectors:   [0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1]
As words:  ['learn', 'orange', 'prefer', 'scikit']
 
Original:  The scikit-learn docs are orange and blue
Vectors:   [0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1]
As words:  ['blue', 'docs', 'learn', 'orange', 'scikit']
 
Original:  New apple logo will be orange and blue
Vectors:   [1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0]
As words:  ['apple', 'blue', 'logo', 'new', 'orange']

8. Korektně provedený zpětný převod vektorů na dokumenty

Předchozí dva demonstrační příklady vypisovaly pouze ta slova, která se v daném dokumentu (v našem případě v jedné větě) vyskytovaly pouze (přesně) jedenkrát. Ovšem pochopitelně není možné ignorovat opakující se slova, takže funkci array_to_words je nutné nepatrně modifikovat do následující podoby:

def array_to_words(feature_names, as_array):
    """Převod matice s frekvencemi slov zpět na slova."""
    return list(
        feature_names[index]
        for index, included in enumerate(as_array[i])
        if included >= 1
    )

Upravený skript:

# Realizace zpětného převodu na slova (korektní práce s opakujícími se slovy)
 
from sklearn.feature_extraction.text import CountVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
print("Feature names count:", len(feature_names))
print()
 
# tabulka indexů slov a vlastních slov
print("Index Feature")
for i, feature_name in enumerate(feature_names):
    print(f"{i:2}    {feature_name}")
 
print()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)
print()
 
 
def array_to_words(feature_names, as_array):
    """Převod matice s frekvencemi slov zpět na slova."""
    return list(
        feature_names[index]
        for index, included in enumerate(as_array[i])
        if included >= 1
    )
 
 
# zpětný převod vět
for i in range(len(corpus)):
    print("Original: ", corpus[i])
    print("Vectors:  ", as_array[i])
    print("As words: ", array_to_words(feature_names, as_array))
    print()

Nyní jsou již výsledky korektní – zpětně zrekonstruované věty bez stopslov a bez správného pořadí slov:

Original:  I'd like an apple or an apple pie
Vectors:   [2 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0]
As words:  ['apple', 'like', 'pie']
 
Original:  An apple a day keeps the doctor away
Vectors:   [1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0]
As words:  ['apple', 'away', 'day', 'doctor', 'keeps']
 
Original:  Never compare an apple to an orange
Vectors:   [1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0]
As words:  ['apple', 'compare', 'orange']
 
Original:  I prefer scikit-learn to orange
Vectors:   [0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1]
As words:  ['learn', 'orange', 'prefer', 'scikit']
 
Original:  The scikit-learn docs are orange and blue
Vectors:   [0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1]
As words:  ['blue', 'docs', 'learn', 'orange', 'scikit']
 
Original:  New apple logo will be orange and blue
Vectors:   [1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0]
As words:  ['apple', 'blue', 'logo', 'new', 'orange']

9. Tf-idf: relevance a specifičnost jednotlivých slov vztažená k aktuálnímu dokumentu i k celému korpusu

Již minule jsme se zmínili o algoritmu pro výpočet relevance jednotlivých slov. Zjednodušeně řečeno se jedná o numerickou hodnotu určující, do jaké míry je nějaké slovo specifické pro určitý dokument. Slova s nízkým ohodnocením jsou příliš obecná a vyskytují se v mnoha dokumentech. A naopak slova s vysokým ohodnocením jsou specifická pro menší počet dokumentů (či dokonce pro jediný dokument). A právě taková slova mají význam jak pro hledání nejbližšího dokumentu, tak i pro trénink modelů.

Můžeme si to ukázat na příkladu. Mějme jazykový korpus, ve kterém budou uloženy texty 1000 knih v angličtině. Slovo „the“ bude mít velmi nízkou specifičnost, protože se vyskytuje v každém dokumentu (knize). Naopak slovo „newspeak“ bude mít vysokou specifičnost v knize „1984“ (vyskytuje se zde mnohokrát) a naopak nízkou nebo nulovou specifičnost v dalších knihách. To například znamená, že model může rozpoznat část textu a říci „toto patří do knihy 1984“ apod. Podobně to může fungovat u algoritmu pro vyhledání podobných textů (vět).

10. Základní vlastnosti výpočtu relevance slov

V následujícím skriptu vektorizujeme korpus obsahující pouze trojici dokumentů (řetězců), přičemž každý řetězec obsahuje pouze tři slova. Všechna slova jsou v tomto případě striktně unikátní – neopakují se:

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
 
# sada textů (korpus)
corpus = [
    "foo bar baz",
    "apple pear orange",
    "Go Python Clojure",
]
 
# provedení vektorizace korpusu
vectorizer = TfidfVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
for index, feature in enumerate(feature_names):
    print(index, feature)
print()
 
# výsledek vektorizace - řídká matice: převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
np.set_printoptions(precision=2)
print(as_array)

Skript nejprve zobrazí vytvořený slovník:

0 apple
1 bar
2 baz
3 clojure
4 foo
5 go
6 orange
7 pear
8 python

Následně se zobrazí vektorizovaná podoba matice:

[[0.   0.58 0.58 0.   0.58 0.   0.   0.   0.  ]
 [0.58 0.   0.   0.   0.   0.   0.58 0.58 0.  ]
 [0.   0.   0.   0.58 0.   0.58 0.   0.   0.58]]

Otázkou je, jakým způsobem se došlo k hodnotám 0,58 (naproti tomu nula je zřejmá – slovo se v daném dokumentu vůbec nevyskytuje).

Provádí se tento výpočet:

idf = log((1+n) / (1 + df(t))) + 1

Dosadíme tedy n=3 (počet dokumentů) a df(t)=1 (počet dokumentů s výskytem slova – to je v našem případě vždy rovno jedné):

idf = log((1+3) / (1 + 1)) + 1 = log(4/2) + 1 = 1,301

Vektory obsahující tyto hodnoty se ovšem ještě normalizují a vzhledem k tomu, že každý vektor obsahuje trojici stejných hodnot, je výpočet poměrně triviální (uvádím ho pro jeden prvek, ale rozšířit se musí na všech šest prvků):

v[1] = 1,301 ÷ sqrt(1,3^2+1,3^2+1,3^2) = 0,577

tedy po zaokrouhlení získáme vektory s prvky 0.58.

11. Další příklady výpočtu tf-idf

Podívejme se nyní na další příklady výpočtu tf-idf. Začneme příkladem, který opět obsahuje tři dokumenty v korpusu, ovšem druhý dokument má jen dvě slova a nikoli slova tři:

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
 
# sada textů (korpus)
corpus = [
    "foo bar baz",
    "apple orange",
    "Go Python Clojure",
]
 
# provedení vektorizace korpusu
vectorizer = TfidfVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
for index, feature in enumerate(feature_names):
    print(index, feature)
print()
 
# výsledek vektorizace - řídká matice: převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
np.set_printoptions(precision=2)
print(as_array)

Kvůli odlišně provedené normalizaci budou ve druhém řádku odlišné hodnoty:

v[1] = 1,301 ÷ sqrt(1,3^2+1,3^2) = 0,707 ≈ 0,71

Což si lze snadno ověřit:

0 apple
1 bar
2 baz
3 clojure
4 foo
5 go
6 orange
7 python
 
[[0.   0.58 0.58 0.   0.58 0.   0.   0.  ]
 [0.71 0.   0.   0.   0.   0.   0.71 0.  ]
 [0.   0.   0.   0.58 0.   0.58 0.   0.58]]

Pojďme ještě dále a upravme poslední dokument tak, že bude obsahovat jen jediné slovo:

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
 
# sada textů (korpus)
corpus = [
    "foo bar baz",
    "apple orange",
    "Go",
]
 
# provedení vektorizace korpusu
vectorizer = TfidfVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
for index, feature in enumerate(feature_names):
    print(index, feature)
print()
 
# výsledek vektorizace - řídká matice: převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
np.set_printoptions(precision=2)
print(as_array)

Zde normalizace výsledek nijak „nespraví“:

v[1] = 1,301 ÷ sqrt(1,3^2) = 1,301/1,301 = 1

To je ostatně patrné i na posledním řádku matice, který obsahuje jedinou hodnotu rovnou jedničce:

0 apple
1 bar
2 baz
3 foo
4 go
5 orange
 
[[0.   0.58 0.58 0.58 0.   0.  ]
 [0.71 0.   0.   0.   0.   0.71]
 [0.   0.   0.   0.   1.   0.  ]]

A konečně si ukažme případ, v němž se jedno slovo „foo“ opakuje ve dvou dokumentech – v dokumentu prvním a třetím:

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
 
# sada textů (korpus)
corpus = [
    "foo bar baz",
    "apple orange",
    "Go foo",
]
 
# provedení vektorizace korpusu
vectorizer = TfidfVectorizer(min_df=1)
vectorized = vectorizer.fit_transform(corpus)
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
for index, feature in enumerate(feature_names):
    print(index, feature)
print()
 
# výsledek vektorizace - řídká matice: převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
np.set_printoptions(precision=2)
print(as_array)

Výsledky nyní budou odlišné:

0 apple
1 bar
2 baz
3 foo
4 go
5 orange
 
[[0.   0.62 0.62 0.47 0.   0.  ]
 [0.71 0.   0.   0.   0.   0.71]
 [0.   0.   0.   0.61 0.8  0.  ]]

Proč tomu tak je? Změní se výpočet idf pro slovo „foo“. Zatímco u slov, které se neopakovaly, stále platí:

idf = log((1+3) / (1 + 1)) + 1 = log(4/2) + 1 = 1,301

tak u slova „foo“ jsou hodnoty odlišné:

idf = log((1 + 3) / (2 + 1)) + 1 = log(4/3) + 1 = 1,12

Tato menší hodnota (pochopitelně po normalizaci) ovlivní právě čtvrtý sloupec v tabulce.

12. Realizace výpočtu matice s relevancí jednotlivých slov

V dalším kroku se pokusme o realizaci jednoduché „pipeline“, ve které se nejprve vypočtou frekvence slov s využitím nám již známé třídy CountVectorizer a následně se provede transformace na hodnoty odpovídající tf-idf. Tato druhá transformace je založena na třídě TfidfTransformer. Postup je stále totožný a odpovídá ustálenému vzoru – konstrukce instance objektu následovaná voláním metody fit, přičemž instanci třídy TfidfTransformer se předává výsledek vektorizace:

vectorizer = CountVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# výpočet IDF - převrácené četnosti slov
transformer = TfidfTransformer(smooth_idf=True, use_idf=True)
transformer.fit(vectorized)

Tento postup je ukázán v následujícím skriptu:

# Výpočet relevance jednotlivých slov
 
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# výpočet IDF - převrácené četnosti slov
transformer = TfidfTransformer(smooth_idf=True, use_idf=True)
transformer.fit(vectorized)
 
# zobrazení tabulky s převrácenými četnostmi jednotlivých slov
for feature_name, idf in zip(feature_names, transformer.idf_):
    print(f"{feature_name:9} {idf:5.2}")

Tento skript nejdříve zobrazí matici s frekvencemi slov:

[[2 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0]
 [1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0]
 [1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0]
 [0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1]
 [0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1]
 [1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0]]

Následně se zobrazí slovník i s vypočtenými hodnotami tf-idf:

apple       1.3
away        2.3
blue        1.8
compare     2.3
day         2.3
docs        2.3
doctor      2.3
keeps       2.3
learn       1.8
like        2.3
logo        2.3
new         2.3
orange      1.3
pie         2.3
prefer      2.3
scikit      1.8

13. Vliv většího množství dokumentů se stejnými slovy v korpusu na vypočtenou relevanci slov

Pokusme se nyní do zpracovávaného korpusu přidat větší množství dalších „dokumentů“, které budou obsahovat stejná slova. To provedeme docela snadno:

# věty pro vyšší četnosti vybraných slov
for i in range(20):
    corpus.append("blue day")

Skript by po svém spuštění měl zobrazit odlišné hodnoty tf-idf u slov „blue“ a „day“, konkrétně by se měly hodnoty u těchto slov snížit. A kvůli způsobu výpočtu se naopak zvýší hodnoty u ostatních slov:

# Výpočet relevance jednotlivých slov
 
from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# věty pro vyšší četnosti vybraných slov
for i in range(20):
    corpus.append("blue day")
 
# provedení vektorizace korpusu
vectorizer = CountVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# slova pro dekódování vah
feature_names = vectorizer.get_feature_names_out()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# výpočet IDF - převrácené četnosti slov
transformer = TfidfTransformer(smooth_idf=True, use_idf=True)
transformer.fit(vectorized)
 
# zobrazení tabulky s převrácenými četnostmi jednotlivých slov
for feature_name, idf in zip(feature_names, transformer.idf_):
    print(f"{feature_name:9} {idf:5.2}")

Původní vypočtená matice s frekvencemi slov:

[[2 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0]
 [1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0]
 [1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0]
 [0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1]
 [0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1]
 [1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0]]

Hodnoty tf-idf vypočtené u jednotlivých slov:

apple       2.7
away        3.6
blue        1.2
compare     3.6
day         1.2
docs        3.6
doctor      3.6
keeps       3.6
learn       3.2
like        3.6
logo        3.6
new         3.6
orange      2.7
pie         3.6
prefer      3.6
scikit      3.2

Zajímavé bude porovnání hodnot z předchozí kapitoly a této kapitoly:

apple       1.3     2.7
away        2.3     3.6
blue        1.8     1.2   (menší)
compare     2.3     3.6
day         2.3     1.2  (menší)
docs        2.3     3.6
doctor      2.3     3.6
keeps       2.3     3.6
learn       1.8     3.2
like        2.3     3.6
logo        2.3     3.6
new         2.3     3.6
orange      1.3     2.7
pie         2.3     3.6
prefer      2.3     3.6
scikit      1.8     3.2
Poznámka: u ostatních slov se jejich hodnota naopak zvýšila, protože jsou nyní méně častá a tím pádem i specifičtější (konkrétně – tato ostatní slova chybí v posledních dvaceti dokumentech).

14. Přímé využití třídy TfidfVectorizer

V předchozím textu jsme si ukázali, jakým způsobem je možné zkombinovat třídu CountVectorizer společně se třídou TfidfTransformer do jednoduché „pipeline“, jejímž výsledkem bude ohodnocení slov v jazykovém korpusu. Ovšem v praxi se setkáme spíše se třídou TfidfVectorizer, která provádí (poněkud zjednodušeně řečeno) obě operace současně. Výsledkem takového výpočtu je matice s váhami slov podle jejich specifičnosti v kontextu jednoho dokumentu (řádek matice) i celého korpusu (sloupec matice). Vlastnosti takových matic i způsob výpočtu jsme si již ukázali v desáté a jedenácté kapitole.

Pokusme se tedy upravit demonstrační příklad z předchozí kapitoly tak, aby se při vektorizaci přímo používala třída TfidfVectorizer. Je to ve skutečnosti velmi snadné:

# Přímý výpočet relevance jednotlivých slov
 
from sklearn.feature_extraction.text import TfidfVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = TfidfVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# převod na běžnou matici
as_array = vectorized.toarray()
 
# zobrazení výsledku v novém formátu
print(as_array)

Výsledek ve formě řídké matice (zobrazují se tedy prvky s nenulovou hodnotou):

  (0, 9)        0.5417030933272916
  (0, 0)        0.642740629927257
  (0, 13)       0.5417030933272916
  (1, 0)        0.2843820458449716
  (1, 4)        0.47935551837885115
  (1, 7)        0.47935551837885115
  (1, 6)        0.47935551837885115
  (1, 1)        0.47935551837885115
  (2, 0)        0.45448625796567665
  (2, 3)        0.7660838613629144
  (2, 12)       0.45448625796567665
  (3, 12)       0.3612599391251273
  (3, 14)       0.6089412039859956
  (3, 15)       0.49934049829319643
  (3, 8)        0.49934049829319643
  (4, 12)       0.32320592952117017
  (4, 15)       0.44674150776102867
  (4, 8)        0.44674150776102867
  (4, 5)        0.5447972125961776
  (4, 2)        0.44674150776102867
  (5, 0)        0.32286546559023394
  (5, 12)       0.32286546559023394
  (5, 2)        0.4462709119088114
  (5, 11)       0.5442233252270988
  (5, 10)       0.5442233252270988

Následuje výsledek ve formě běžné matice. Čím vyšší je nějaká hodnota, tím specifičtější slovo bylo použito (a současně i tím kratší je dokument):

[[0.64 0.   0.   0.   0.   0.   0.   0.   0.   0.54 0.   0.   0.   0.54 0.   0.  ]
 [0.28 0.48 0.   0.   0.48 0.   0.48 0.48 0.   0.   0.   0.   0.   0.   0.   0.  ]
 [0.45 0.   0.   0.77 0.   0.   0.   0.   0.   0.   0.   0.   0.45 0.   0.   0.  ]
 [0.   0.   0.   0.   0.   0.   0.   0.   0.5  0.   0.   0.   0.36 0.   0.61 0.5 ]
 [0.   0.   0.45 0.   0.   0.54 0.   0.   0.45 0.   0.   0.   0.32 0.   0.   0.45]
 [0.32 0.   0.45 0.   0.   0.   0.   0.   0.   0.   0.54 0.54 0.32 0.   0.   0.  ]]

15. Nalezení textu, který se nejvíce blíží hledanému vzorku

Ukažme si nyní jedno praktické použití matic s hodnotami tf-idf. Naimplementujeme si algoritmus, která se v korpusu pokusí najít větu (dokument), který se nejvíce blíží hledanému vzorku. Existuje hned několik metod, jak toho dosáhnout, ovšem nejjednodušší a vlastně i nejrychlejší metoda je založena právě na použití matice s hodnotami tf-idf.

Vstupem bude matice získaná vektorizací korpusu. Ta bude obsahovat například následujících sedm vektorů pro sedm dokumentů (řetězců):

[[0.6427 0.     0.     0.     0.     0.     0.     0.     0.     0.5417 0.     0.     0.     0.5417 0.     0.    ]
 [0.2844 0.4794 0.     0.     0.4794 0.     0.4794 0.4794 0.     0.     0.     0.     0.     0.     0.     0.    ]
 [0.4545 0.     0.     0.7661 0.     0.     0.     0.     0.     0.     0.     0.     0.4545 0.     0.     0.    ]
 [0.     0.     0.     0.     0.     0.     0.     0.     0.4993 0.     0.     0.     0.3613 0.     0.6089 0.4993]
 [0.     0.     0.4467 0.     0.     0.5448 0.     0.     0.4467 0.     0.     0.     0.3232 0.     0.     0.4467]
 [0.3229 0.     0.4463 0.     0.     0.     0.     0.     0.     0.     0.5442 0.5442 0.3229 0.     0.     0.    ]]

Jak však zjistit, které dokumenty se nejvíce podobají? Můžeme využít toho, že podobné dokumenty budou pravděpodobně obsahovat podobná slova a největší váhu mají mít slova s vyšší hodnotou v matici, protože tato slova jsou více specifická. Takže vlastně můžeme využít skalárních součinů vektorů získaných z jazykového korpusu, který bude obsahovat jak hledanou větu, tak i vzorek. Skalární součin dvou vektorů můžeme vypočítat snadno, ovšem všechny skalární součiny jsou de facto realizovány maticovým součinem, konkrétně součinem výše uvedené matice se stejnou maticí, která je však nejdříve transponována. Výsledkem by měla být matice 7×7 prvků:

[[1.     0.1828 0.2921 0.     0.     0.2075]
 [0.1828 1.     0.1292 0.     0.     0.0918]
 [0.2921 0.1292 1.     0.1642 0.1469 0.2935]
 [0.     0.     0.1642 1.     0.5629 0.1166]
 [0.     0.     0.1469 0.5629 1.     0.3037]
 [0.2075 0.0918 0.2935 0.1166 0.3037 1.    ]]

V této nové matici prvek A[i,j] říká, jak moc se podobají dokumenty s indexy i a j, přičemž pochopitelně platí, že dokument se nejvíce podobá sobě samotnému (hlavní diagonála). Z tohoto důvodu nejdříve z hlavní diagonály hodnoty vymažeme (nahradíme je za „nečísla“). Dostaneme následující matici:

[[   nan 0.1828 0.2921 0.     0.     0.2075]
 [0.1828    nan 0.1292 0.     0.     0.0918]
 [0.2921 0.1292    nan 0.1642 0.1469 0.2935]
 [0.     0.     0.1642    nan 0.5629 0.1166]
 [0.     0.     0.1469 0.5629    nan 0.3037]
 [0.2075 0.0918 0.2935 0.1166 0.3037    nan]]

Lze tedy relativně snadno zjistit, že nejvíce se podobají dokumenty číslo 3 a 4 (číslováno od nuly) a nejméně například dokument 0 a 3. A poslední dokument je nejvíce podobný dokumentu číslo 4.

Poznámka: zde je situace triviální, protože máme k dispozici pouze šest dokumentů a šestnáct slov ve slovníku, ale v praxi budou rozměry matice mnohem větší.

16. Realizace algoritmu pro nalezení nejpodobnější věty

Vyzkoušejme si nyní konkrétní realizaci algoritmu, s nímž jsme se právě seznámili. Je zde provedena transpozice matice s výpočtem součinu matice představující původní vektorizovaný korpus s transponovanou maticí. Navíc jsou z výsledné matice odstraněny prvky na hlavní diagonále a následně je tato nová matice použita pro nalezení, která další věta z korpusu je nejbližší větě „New apple logo will be orange and blue“:

# Nalezení textu, který se nejvíce blíží hledanému vzorku
 
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
 
# sada textů (korpus)
corpus = [
    "I'd like an apple or an apple pie",
    "An apple a day keeps the doctor away",
    "Never compare an apple to an orange",
    "I prefer scikit-learn to orange",
    "The scikit-learn docs are orange and blue",
    "New apple logo will be orange and blue",
]
 
# provedení vektorizace korpusu
vectorizer = TfidfVectorizer(min_df=1, stop_words="english")
vectorized = vectorizer.fit_transform(corpus)
 
# výsledek vektorizace - řídká matice
print(vectorized)
print()
 
# matice s převrácenými četnostmi
pairwise_similarity = vectorized * vectorized.T
 
print(pairwise_similarity)
print()
 
print(pairwise_similarity.toarray())
print()
 
arr = pairwise_similarity.toarray()
 
# odstranění jedniček na hlavní diagonále
np.fill_diagonal(arr, np.nan)
print(arr)
print()
 
# hledaná věta
input_doc = "New apple logo will be orange and blue"
input_idx = corpus.index(input_doc)
print(input_idx, input_doc)
 
result_idx = np.nanargmax(arr[input_idx])
print(result_idx, corpus[result_idx])

Tento skript nejdříve vypíše použité matice (ty jsme si však již uvedli v předchozím textu, takže je zde nebudu opakovat) a nakonec určí, která věta je nejbližší větě zadané. Je to věta číslo 4 z našeho jazykového korpusu:

4 The scikit-learn docs are orange and blue

17. Úskalí algoritmu pro hledání podobných textů

Algoritmus určený pro vyhledávání podobných textů v realizaci, v jaké byl právě představen, trpí jednou zásadní vadou – nedokáže totiž korektně rozlišit pořadí slov a navíc (většinou) jsou z vektorizovaného textu odstraněna stopslova, která v některých případech mohou měnit smysl textu. To například může znamenat, že dvě věty (nebo delší sekvence textu), které mají zcela opačný význam kvůli použití slov jako „no“, „not“ atd., budou ve skutečnosti považovány za věty velmi si podobné.

Oba zmíněné nedostatky je možné do značné míry odstranit takovým způsobem, že při vektorizaci jazykového korpusu budeme do slovníku ukládat nikoli samostatná slova, ale například dvojice slov. Celý slovník se pochopitelně zvětší a tím pádem se zvětší i matice s vektorizovaným textem, ovšem v některých situacích je to jedno z mála praktických řešení, které je navíc možné velmi snadno implementovat. Základy tohoto postupu si vysvětlíme v navazujícím článku.

18. Vektorizovaný text a neuronové sítě

Vraťme se ještě na chvíli k minulému článku, v němž jsme se pokusili natrénovat model určený pro rozeznávání pozitivně, negativně nebo neutrálně naladěných tweetů o dopravcích. Samozřejmě nám nic nebrání v tom, abychom pro model využili neuronovou síť a (možná?) tak zlepšili jeho predikční schopnosti. Ukažme si, jak by celý postup mohl vypadat. Neuronovou síť prozatím ponecháme v původní podobě – nebudeme ji tedy nijak „dolaďovat“:

# Trénink a predikce modelu nad vektorizovanými daty
 
import pandas as pd
import re
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
 
# model zalozeny na neuronove siti
from sklearn.neural_network import MLPClassifier
 
 
 
# načtení tabulky do datového rámce s předzpracováním numerických dat
airline_tweets = pd.read_csv("Tweets_airlines.csv")
 
# hodnocení (pozitivní, negativní, neutrální)
labels = airline_tweets["airline_sentiment"].values
 
# vlastní text hodnocení
features = airline_tweets["text"].values
 
 
def process_feature(feature):
    """Preprocesing textových dat."""
    # odstranění speciálních znaků a dalšího smetí
    processed_feature = re.sub(r"\W", " ", feature)
 
    # odstranění samostatných znaků (oddělených bílými znaky)
    processed_feature = re.sub(r"\s+[a-zA-Z]\s+", " ", processed_feature)
 
    # odstranění samostatných znaků na začátku vět
    processed_feature = re.sub(r"\^[a-zA-Z]\s+", " ", processed_feature)
 
    # náhrada více mezer (nebo jiných bílých znaků) za jedinou mezeru
    processed_feature = re.sub(r"\s+", " ", processed_feature, flags=re.I)
 
    # odstranění prefixů ^b
    processed_feature = re.sub(r"^b\s+", "", processed_feature)
 
    # konverze výsledku na malá písmena
    return processed_feature.lower()
 
 
# preprocesing všech hodnocení
processed_features = [process_feature(feature) for feature in features]
 
# hodnoty použité později pro trénink modelu
print("Labels:")
print(labels)
print("Number of labels:", len(labels))
print()
 
print("Features:")
print(processed_features)
print("Number of features:", len(processed_features))
print()
 
# vektorizace textu
vectorizer = TfidfVectorizer(
    max_features=2500, min_df=7, max_df=0.8, stop_words=stopwords.words("english")
)
vectorized_features = vectorizer.fit_transform(processed_features).toarray()
 
# klasické rozdělení datové sady na trénovací a testovací část
trainX, testX, trainY, testY = train_test_split(
    vectorized_features, labels, test_size=0.2, random_state=0
)
 
# konstrukce vybraného modelu s předáním hyperparametrů
classifier =  MLPClassifier(max_iter=5000)
 
# trénink modelu
classifier.fit(trainX, trainY)
 
# predikce modelu pro testovací vstupy (ne pro trénovací data)
predictions = classifier.predict(testX)
 
# vyhodnocení kvality modelu
print(classification_report(testY, predictions))
print(accuracy_score(testY, predictions))
 
# matice záměn - absolutní hodnoty
disp = ConfusionMatrixDisplay.from_estimator(
    classifier,
    testX,
    testY,
    cmap=plt.cm.Blues,
    normalize=None,
)
 
# zobrazení matice v textové podobě
print(disp.confusion_matrix)
 
# uložení výsledků ve formě rastrového obrázku
plt.savefig("189_1.png")
 
# vizualizace matice
plt.show()
 
# matice záměn - relativní hodnoty
disp = ConfusionMatrixDisplay.from_estimator(
    classifier,
    testX,
    testY,
    cmap=plt.cm.Blues,
    normalize="true",
)
 
# zobrazení matice v textové podobě
print(disp.confusion_matrix)
 
# uložení výsledků ve formě rastrového obrázku
plt.savefig("189_2.png")
 
# vizualizace matice
plt.show()

Matice záměn budou vypadat takto:

Obrázek 1: Matice záměn s absolutními hodnotami.

Obrázek 2: Matice záměn s relativními hodnotami.

bitcoin školení listopad 24

Poznámka: z těchto obrázků je patrný fakt (o němž jsme se zmínili už minule), že nejvíce hodnocení je negativních. A dále je patrné, že model stále nedokáže přesně rozhodnout, jaké hodnocení jednotlivé tweety obsahují, protože míra špatného odhadu je relativně vysoká. I přesto jsou nejvyšší relativní hodnoty stále na hlavní diagonále, takže model neodpovídá zcela náhodně.

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
143 143_mlp_regression2.py další modifikace parametrů neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/143_mlp_re­gression2.py
144 144_mlp_regression3.py postupná změna počtu neuronů v jedné skryté vrstvě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/144_mlp_re­gression3.py
145 145_mlp_regression4.py postupná změna počtu neuronů ve třech skrytých vrstvách https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/145_mlp_re­gression4.py
146 146_mlp_regression5.py postupná změna počtu neuronů v pěti skrytých vrstvách https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/146_mlp_re­gression5.py
147 147_mlp_regression6.py postupná změna počtu skrytých vrstev při zachování počtu neuronů v každé vrstvě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/147_mlp_re­gression6.py
       
148 148_confusion_matrix1.py zjištění kvality modelu s využitím matice záměn (confusion matrix) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/148_con­fusion_matrix1.py
149 149_confusion_matrix2.py zjištění kvality modelu hledajícího K nejbližších sousedů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/149_con­fusion_matrix2.py
150 150_confusion_matrix3.py zjištění kvality modelu tvořeného neuronovou sítí https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/150_con­fusion_matrix3.py
       
151 151_multiplication_table.py využití neuronové sítě pro odhad výsledků součinu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/151_mul­tiplication_table.py
152 152_multiplication_table.py odhad/vygenerování celé matice malé násobilky neuronovou sítí https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/152_mul­tiplication_table.py
153 153_multiplication_table.py rozšíření výpočtu součinu na rozsah 20×20 (při zachování původní sítě) https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/153_mul­tiplication_table.py
       
154 154_images1.py rozpoznání číslic modelem provádějícím logistickou regresi https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/154_i­mages1.py
155 155_images2.py rozpoznání číslic: využití modelu SVM (metoda podpůrných vektorů) pro klasifikaci obrázků https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/155_i­mages2.py
156 156_images3.py rozpoznání číslic: využití modelu pro hledání K nejbližších sousedů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/156_i­mages3.py
157 157_images4.py rozpoznání rastrových obrázků neuronovou sítí https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/157_i­mages4.py
158 158_all_predictions.py zobrazení původních obrázků i predikovaných výsledků ve vizuální podobě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/158_a­ll_predictions.py
159 159_wrong_predictions.py zobrazení 25 nekorektních odhadů modelu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/159_wron­g_predictions.py
160 160_nn_wrong_predictions.py zobrazení 25 nekorektních odhadů neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/160_nn_wron­g_predictions.py
       
161 161_activation_function.py specifikace aktivační funkce neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/161_ac­tivation_function.py
162 162_solver.py specifikace trénovacího a učícího algoritmu neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/162_solver.py
163 163_best_combination.py kombinace nejlepší aktivační funkce a nejlepšího trénovacího algoritmu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/163_bes­t_combination.py
       
164 164_simplestnn.py neuronová síť s pouhými třemi neurony https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/164_sim­plestnn.py
165 165_no_randomization.py odstranění náhody z procesu tréninku a testování neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/165_no_ran­domization.py
166 166_step_by_step.py postupné zvětšování počtu vzorků použitých pro trénink neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/166_step_by_step­.py
167 167_weights_biases.py grafické znázornění závislosti MSE, vah neuronů a biasu na počtu vzorků https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/167_we­ights_biases.py
168 168_maxiter.py zrychlení tréninku neuronové sítě snížením počtu iterací https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/168_ma­xiter.py
169 169_learning_rate.py vyšší míra změny vah na vstupu neuronů při tréninku https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/169_le­arning_rate.py
170 170_too_fast_rate.py riziko příliš vysoké hodnoty learning_rate_init https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/170_to­o_fast_rate.py
171 171_too_slow_rate.py opačný extrém – příliš malá hodnota learning_rate_init https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/171_to­o_slow_rate.py
       
172 172_download_dataset.py získání datové sady s tweety o dopravcích https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/172_dow­nload_dataset.py
173 173_download_stopwords.py získání slovníku se stopslovy https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/173_dow­nload_stopwords.py
174 174_read_airline_tweets.py načtení datové sady s tweety o dopravcích https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/174_re­ad_airline_tweets.py
175 175_airline_tweets_info.py informace o načtené datové sadě s tweety o dopravcích https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/175_a­irline_tweets_info.py
176 176_airline_tweets_statistic.py základní statistické údaje o datové sadě s tweety o dopravcích https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/176_a­irline_tweets_statistic.py
177 177_tweets_per_airline.py statistika: počet tweetů o jednotlivých dopravcích https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/177_twe­ets_per_airline.py
178 178_tweets_bar_chart.py vizualizace počtu tweetů o jednotlivých dopravcích na sloupcovém diagramu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/178_twe­ets_bar_chart.py
179 179_tweets_pie_chart.py vizualizace počtu tweetů o jednotlivých dopravcích na koláčovém diagram https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/179_twe­ets_pie_chart.py
180 180_sentiments.py výpočet hodnocení jednotlivých dopravců https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/180_sen­timents.py
181 181_sentiments_piechart.py vizualizace hodnocení jednotlivých dopravců https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/181_sen­timents_piechart.py
182 182_sentiment_per_airline.py výpočet hodnocení vztažených k jednotlivým dopravcům https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/182_sen­timent_per_airline.py
183 183_sentiment_per_airline.py výpočet hodnocení vztažených k jednotlivým dopravcům https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/183_sen­timent_per_airline.py
184 184_features.py přečtení potřebných atributů z datové sady pro trénink modelu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/184_fe­atures.py
185 185_processing.py předzpracování textových dat https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/185_pro­cessing.py
186 186_vectorization.py vektorizace textových dat pomocí třídy CountVectorizer https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/186_vec­torization.py
187 187_vectorization.py vektorizace textových dat pomocí třídy TfidfVectorizer https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/187_vec­torization.py
188 188_vectorization_and_training.py trénink modelu https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/188_vec­torization_and_training.py
189 189_vectorization_andnn.py trénink modelu s využitím neuronové sítě https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/189_vec­torization_andnn.py
       
190 190_count_vectorizer.py základní vektorizace s využitím třídy CountVectorizer https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/190_cou­nt_vectorizer.py
191 191_words_to_vec.py převod sekvence slov do vektorové podoby https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/191_wor­ds_to_vec.py
192 192_vec_to_words.py zpětný převod z vektorové podoby na sekvenci slov https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/192_vec_to_wor­ds.py
193 193_use_english_stopwords.py použití anglických stopslov při vektorizaci https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/193_u­se_english_stopwords.py
194 194_correct_vec_to_words.py korektně realizovaný zpětný převod z vektorové podoby na sekvenci slov https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/194_co­rrect_vec_to_words.py
195 195_tfidf_transformer.py vektorizace s využitím třídy TfidfTransformer https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/195_tfid­f_transformer.py
196 196_more_frequent_words.py výsledná matice v případě, že se v dokumentech opakují slova https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/196_mo­re_frequent_words.py
197 197_tfidf_vectorizer.py vektorizace realizovaná s využitím třídy TfidfVectorizer https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/197_tfid­f_vectorizer.py
198 198_sentence_similarity.py nalezení podobných dokumentů https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/198_sen­tence_similarity.py
       
199 199_cut_off.py vliv parametru cut off na výsledek vektorizace https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/199_cut_of­f.py
200 200_max_df.py vliv parametru max_df na výsledek vektorizace https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/200_max_df.py
201 201_tfid_vectorizer_check1.py zkoumání vlastnosti vektorizace pomocí třídy TfidfVectorizer: rozdílná slova, rozdílné dokumenty https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/201_tfid_vec­torizer_check1.py
202 202_tfid_vectorizer_check2.py zkoumání vlastnosti vektorizace pomocí třídy TfidfVectorizer: opakující se slova https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/202_tfid_vec­torizer_check2.py
203 203_tfid_vectorizer_check3.py zkoumání vlastnosti vektorizace pomocí třídy TfidfVectorizer: kratší dokumenty https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/203_tfid_vec­torizer_check3.py
204 204_tfid_vectorizer_check4.py zkoumání vlastnosti vektorizace pomocí třídy TfidfVectorizer: kratší dokumenty https://github.com/tisnik/most-popular-python-libs/blob/master/sklearn/204_tfid_vec­torizer_check4.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. Python for NLP: Sentiment Analysis with Scikit-Learn
    https://stackabuse.com/python-for-nlp-sentiment-analysis-with-scikit-learn/
  2. Datová sada – hodnocení leteckých dopravců
    https://raw.githubusercon­tent.com/satyajeetkrjha/kag­gle-Twitter-US-Airline-Sentiment-/refs/heads/master/Tweets.csv
  3. Twitter_US_Airline_Sentiment_Analysis
    https://github.com/rustagi­janvi/Twitter_US_Airline_Sen­timent_Analysis/tree/main
  4. Shluková analýza (clustering) a knihovna Scikit-learn
    https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn/
  5. Shluková analýza (clustering) a knihovna Scikit-learn (2)
    https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn-2/
  6. 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/
  7. Rozpoznávání obrázků knihovnou Scikit-learn: první kroky
    https://www.root.cz/clanky/roz­poznavani-obrazku-knihovnou-scikit-learn-prvni-kroky/
  8. scikit-learn: Machine Learning in Python
    https://scikit-learn.org/stable/index.html
  9. Sklearn-pandas
    https://github.com/scikit-learn-contrib/sklearn-pandas
  10. sklearn-xarray
    https://github.com/phausamann/sklearn-xarray/
  11. Clustering
    https://scikit-learn.org/stable/modules/clus­tering.html
  12. Cluster analysis (Wikipedia)
    https://en.wikipedia.org/wi­ki/Cluster_analysis
  13. Shluková analýza (Wikipedia)
    https://cs.wikipedia.org/wi­ki/Shlukov%C3%A1_anal%C3%BDza
  14. K-means
    https://cs.wikipedia.org/wiki/K-means
  15. k-means clustering
    https://en.wikipedia.org/wiki/K-means_clustering
  16. Spectral clustering
    https://en.wikipedia.org/wi­ki/Spectral_clustering
  17. Emergence
    https://cs.wikipedia.org/wi­ki/Emergence
  18. Particle Life: Vivid structures from rudimentary rules
    https://particle-life.com/
  19. Hertzsprungův–Russellův diagram
    https://cs.wikipedia.org/wi­ki/Hertzsprung%C5%AFv%E2%80%93Rus­sell%C5%AFv_diagram
  20. Using Machine Learning in an HR Diagram
    https://cocalc.com/share/pu­blic_paths/08b6e03583cbdef3cdb98­13a54ec68ff773c747f
  21. Gaia H-R diagrams: Querying Gaia data for one million nearby stars
    https://vlas.dev/post/gaia-dr2-hrd/
  22. The Hertzsprung–Russell diagram
    https://scipython.com/book2/chapter-9-data-analysis-with-pandas/problems/p92/the-hertzsprung-russell-diagram/
  23. Animated Hertzsprung-Russell Diagram with 119,614 datapoints
    https://github.com/zonination/h-r-diagram
  24. Neuraxle Pipelines
    https://github.com/Neuraxio/Neuraxle
  25. scikit-learn: Getting Started
    https://scikit-learn.org/stable/getting_started.html
  26. Support Vector Machines
    https://scikit-learn.org/stable/modules/svm.html
  27. Use Deep Learning to Detect Programming Languages
    http://searene.me/2017/11/26/use-neural-networks-to-detect-programming-languages/
  28. Natural-language processing
    https://en.wikipedia.org/wiki/Natural-language_processing
  29. THE MNIST DATABASE of handwritten digits
    http://yann.lecun.com/exdb/mnist/
  30. MNIST database (Wikipedia)
    https://en.wikipedia.org/wi­ki/MNIST_database
  31. MNIST For ML Beginners
    https://www.tensorflow.or­g/get_started/mnist/begin­ners
  32. Stránka projektu Torch
    http://torch.ch/
  33. Torch: Serialization
    https://github.com/torch/tor­ch7/blob/master/doc/seria­lization.md
  34. Torch: modul image
    https://github.com/torch/i­mage/blob/master/README.md
  35. Data pro neuronové sítě
    http://archive.ics.uci.edu/ml/in­dex.php
  36. Torch na GitHubu (několik repositářů)
    https://github.com/torch
  37. Torch (machine learning), Wikipedia
    https://en.wikipedia.org/wi­ki/Torch_%28machine_learnin­g%29
  38. Torch Package Reference Manual
    https://github.com/torch/tor­ch7/blob/master/README.md
  39. Torch Cheatsheet
    https://github.com/torch/tor­ch7/wiki/Cheatsheet
  40. Neural network containres (Torch)
    https://github.com/torch/nn/blob/mas­ter/doc/containers.md
  41. Simple layers
    https://github.com/torch/nn/blob/mas­ter/doc/simple.md#nn.Line­ar
  42. Transfer Function Layers
    https://github.com/torch/nn/blob/mas­ter/doc/transfer.md#nn.tran­sfer.dok
  43. Feedforward neural network
    https://en.wikipedia.org/wi­ki/Feedforward_neural_net­work
  44. Biologické algoritmy (4) – Neuronové sítě
    https://www.root.cz/clanky/biologicke-algoritmy-4-neuronove-site/
  45. Biologické algoritmy (5) – Neuronové sítě
    https://www.root.cz/clanky/biologicke-algoritmy-5-neuronove-site/
  46. Umělá neuronová síť (Wikipedia)
    https://cs.wikipedia.org/wi­ki/Um%C4%9Bl%C3%A1_neuronov%C3%A1_s%C3%AD%C5%A5
  47. PyTorch
    http://pytorch.org/
  48. JupyterLite na PyPi
    https://pypi.org/project/jupyterlite/
  49. JupyterLite na GitHubu
    https://github.com/jupyter­lite/jupyterlite
  50. Dokumentace k projektu JupyterLite
    https://github.com/jupyter­lite/jupyterlite
  51. Matplotlib Home Page
    http://matplotlib.org/
  52. Matplotlib (Wikipedia)
    https://en.wikipedia.org/wi­ki/Matplotlib
  53. Popis barvových map modulu matplotlib.cm
    https://gist.github.com/en­dolith/2719900#id7
  54. Ukázky (palety) barvových map modulu matplotlib.cm
    http://matplotlib.org/exam­ples/color/colormaps_refe­rence.html
  55. Galerie grafů vytvořených v Matplotlibu
    https://matplotlib.org/3.2.1/gallery/
  56. 3D rendering
    https://en.wikipedia.org/wi­ki/3D_rendering
  57. 3D computer graphics
    https://en.wikipedia.org/wi­ki/3D_computer_graphics
  58. Primary 3D view planes
    https://matplotlib.org/sta­ble/gallery/mplot3d/view_pla­nes_3d.html
  59. Getting started in scikit-learn with the famous iris dataset
    https://www.youtube.com/wat­ch?v=hd1W4CyPX58
  60. Training a machine learning model with scikit-learn
    https://www.youtube.com/wat­ch?v=RlQuVL6-qe8
  61. Iris (plant)
    https://en.wikipedia.org/wi­ki/Iris_(plant)
  62. Kosatec
    https://cs.wikipedia.org/wiki/Kosatec
  63. Iris setosa
    https://en.wikipedia.org/wi­ki/Iris_setosa
  64. Iris versicolor
    https://en.wikipedia.org/wi­ki/Iris_versicolor
  65. Iris virginica
    https://en.wikipedia.org/wi­ki/Iris_virginica
  66. Druh
    https://cs.wikipedia.org/wiki/Druh
  67. Iris subg. Limniris
    https://en.wikipedia.org/wi­ki/Iris_subg._Limniris
  68. Iris Dataset Classification with Python: A Tutorial
    https://www.pycodemates.com/2022/05/i­ris-dataset-classification-with-python.html
  69. Iris flower data set
    https://en.wikipedia.org/wi­ki/Iris_flower_data_set
  70. List of datasets for machine-learning research
    https://en.wikipedia.org/wi­ki/List_of_datasets_for_machi­ne-learning_research
  71. Analýza hlavních komponent
    https://cs.wikipedia.org/wi­ki/Anal%C3%BDza_hlavn%C3%AD­ch_komponent
  72. Principal component analysis
    https://en.wikipedia.org/wi­ki/Principal_component_ana­lysis
  73. Scikit-learn Crash Course – Machine Learning Library for Python
    https://www.youtube.com/wat­ch?v=0B5eIE_1vpU
  74. calm-notebooks
    https://github.com/koaning/calm-notebooks
  75. Should you teach Python or R for data science?
    https://www.dataschool.io/python-or-r-for-data-science/
  76. nbviewer: A simple way to share Jupyter Notebooks
    https://nbviewer.org/
  77. AI vs Machine Learning (Youtube)
    https://www.youtube.com/wat­ch?v=4RixMPF4×is
  78. Machine Learning | What Is Machine Learning? | Introduction To Machine Learning | 2024 | Simplilearn (Youtube)
    https://www.youtube.com/wat­ch?v=ukzFI9rgwfU
  79. A Gentle Introduction to Machine Learning (Youtube)
    https://www.youtube.com/wat­ch?v=Gv9_4yMHFhI
  80. Machine Learning vs Deep Learning
    https://www.youtube.com/wat­ch?v=q6kJ71tEYqM
  81. Umělá inteligence (slajdy)
    https://slideplayer.cz/sli­de/12119218/
  82. Úvod do umělé inteligence
    https://slideplayer.cz/slide/2505525/
  83. Umělá inteligence I / Artificial Intelligence I
    https://ktiml.mff.cuni.cz/~bartak/ui/
  84. 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/
  85. Matplotlib, Seaborn or Plotnine?
    https://www.reddit.com/r/da­tascience/comments/jvrqxt/mat­plotlib_seaborn_or_plotni­ne/
  86. @Rabeez: Rabeez/plotting_comparison.ipynb
    https://gist.github.com/Ra­beez/ffc0b59d4a41e20fa8d94­4c44a96adbc
  87. Matplotlib, Seaborn, Plotly and Plotnine Comparison
    https://python.plainenglish­.io/matplotlib-seaborn-plotly-and-plotnine-comparison-baf2db5a9c40
  88. Data Visualization 101: How to Choose a Python Plotting Library
    https://towardsdatascience.com/data-visualization-101-how-to-choose-a-python-plotting-library-853460a08a8a
  89. Data science in Python: pandas, seaborn, scikit-learn
    https://www.youtube.com/wat­ch?v=3ZWuPVWq7p4
  90. 7.2. Real world datasets
    https://scikit-learn.org/stable/datasets/re­al_world.html#california-housing-dataset
  91. 7.2.7. California Housing dataset
    https://scikit-learn.org/stable/datasets/re­al_world.html#california-housing-dataset
  92. Comprehensive Guide to Classification Models in Scikit-Learn
    https://www.geeksforgeeks­.org/comprehensive-guide-to-classification-models-in-scikit-learn/
  93. Tidy Data Visualization: ggplot2 vs seaborn
    https://blog.tidy-intelligence.com/posts/ggplot2-vs-seaborn/
  94. seaborn: statistical data visualization
    https://seaborn.pydata.org/
  95. Linear regression (Wikipedia)
    https://en.wikipedia.org/wi­ki/Linear_regression
  96. Lineární regrese (Wikipedia)
    https://cs.wikipedia.org/wi­ki/Line%C3%A1rn%C3%AD_regre­se
  97. 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.