Obsah
1. Redukce atributů v datových sadách před tréninkem modelů
3. Získané statistické informace
4. Výběr atributů pro trénink modelu s využitím filtru VarianceThreshold
5. Získání jmen atributů původní datové sady a datové sady redukované
6. Výběr (filtrace) atributů pro různé mezní hodnoty (threshold)
7. Výběr K nejvhodnějších atributů pro trénink
8. Výběr čtyř nejvhodnějších atributů datové sady California Housings
9. Výběr atributů pro postupně rostoucí hodnotu K
10. Použití modelu pro výběr atributů
11. Ukázka využití modelu pro výběr atributů
12. Křížová validace modelu naučeného s využitím vyfiltrované skupiny atributů
13. Křížová validace pro model natrénovaný na datovou sadu Iris
14. Výsledky křížové validace pro datovou sadu Iris
15. Křížová validace pro model natrénovaný na datovou sadu California Housings
16. Výsledky křížové validace pro datovou sadu California housings
17. Výsledky křížové validace pro filtraci pomocí VarianceThreshold
18. Obsah navazujícího článku – neuronové sítě
19. Repositář s demonstračními příklady
1. Redukce atributů v datových sadách před tréninkem modelů
Poměrně často se setkáme s daty (resp. přesněji řečeno s datovými sadami), které obsahují velké množství atributů. Příkladem může být například datová sada s parametry různých typů vín, která pro každé víno obsahuje jednu hodnotu s odpovědí a třináct dalších atributů, které je možné (nikoli nutné) použít pro trénink:
Variable Name Role class Target Alcohol Feature Malicacid Feature Ash Feature Alcalinity_of_ash Feature Magnesium Feature Total_phenols Feature Flavanoids Feature Nonflavanoid_phenols Feature Proanthocyanins Feature Color_intensity Feature Hue Feature 0D280_0D315_of_diluted_wines Feature Proline Feature
Většinou ovšem dopředu nevíme, které z těchto atributů má smysl použít pro trénink modelu a které atributy jsou naopak zbytečné či dokonce nevhodné (příliš náhodné atd.). Dnes si tedy ukážeme několik způsobů filtrace vhodných a nevhodných atributů. Opět pochopitelně použijeme knihovnu scikit-learn.
2. Získání základních statistických informací o atributech v datových sadách Iris i California Housings
Nejprve si ukažme resp. přesněji řečeno připomeňme, jakým způsobem můžeme získat základní statistické informace o atributech v datových sadách. Podobně jako v předchozích částech tohoto seriálu i dnes použijeme datové sady Iris (čtyři atributy se stejnými jednotkami i měřítkem) a California Housings (osm atributů z různými jednotkami a samozřejmě i s rozdílným měřítkem).
Získání a výpočet statistických informací pro datovou sadu Iris:
import numpy as np
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import load_iris
# nacteni datove sady
iris = load_iris()
# precteni dat z datove sady
data = iris["data"]
# nadpis tabulky
print("Feature Min Max Avg Std Var")
# zakladni statisticke informace o jednotlivych atributech
for i in range(len(iris["feature_names"])):
column = data[:, i]
feature = iris.feature_names[i]
print(f"{feature:20} {column.min():10.3f} {column.max():10.3f} {np.mean(column):10.3f} {np.std(column):10.3f} {np.var(column):11.3f}")
Získání a výpočet statistických informací pro datovou sadu California Housings:
import numpy as np
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import fetch_california_housing
# nacteni datove sady
housings = fetch_california_housing()
# precteni dat z datove sady
data = housings["data"]
# nadpis tabulky
print("Feature Min Max Avg Std Var")
# zakladni statisticke informace o jednotlivych atributech
for i in range(len(housings["feature_names"])):
column = data[:, i]
feature = housings.feature_names[i]
print(f"{feature:12} {column.min():10.3f} {column.max():10.3f} {np.mean(column):10.3f} {np.std(column):10.3f} {np.var(column):11.3f}")
3. Získané statistické informace
Výše uvedené skripty vypočítaly pro každý z atributů nejmenší a největší hodnotu atributu, průměrnou hodnotu, směrodatnou odchylku a rozptyl:
Feature Min Max Avg Std Var sepal length (cm) 4.300 7.900 5.843 0.825 0.681 sepal width (cm) 2.000 4.400 3.057 0.434 0.189 petal length (cm) 1.000 6.900 3.758 1.759 3.096 petal width (cm) 0.100 2.500 1.199 0.760 0.577
Pro datovou sadu California Housings dostaneme značně odlišné hodnoty. Především stojí za pozornost velká odchylka a rozptyl pro atribut Population:
Feature Min Max Avg Std Var MedInc 0.500 15.000 3.871 1.900 3.609 HouseAge 1.000 52.000 28.639 12.585 158.389 AveRooms 0.846 141.909 5.429 2.474 6.121 AveBedrms 0.333 34.067 1.097 0.474 0.225 Population 3.000 35682.000 1425.477 1132.435 1282408.322 AveOccup 0.692 1243.333 3.071 10.386 107.865 Latitude 32.540 41.950 35.632 2.136 4.562 Longitude -124.350 -114.310 -119.570 2.003 4.014
Ignored attribute MSE r2 score MedInc 0.805 0.392 HouseAge 0.535 0.601 AveRooms 0.536 0.596 AveBedrms 0.541 0.598 Population 0.525 0.605 AveOccup 0.539 0.596 Latitude 0.617 0.535 Longitude 0.619 0.538
4. Výběr atributů pro trénink modelu s využitím filtru VarianceThreshold
Jedním z filtrů sloužících pro snížení počtu atributů, se kterými se bude model trénovat, je filtr nazvaný VarianceThreshold. Tento filtr odstraní atribut či atributy s nejmenším (nikoli největším) rozptylem. Filtr přímo vrací novou datovou sadu. Podívejme se na jeho použití, přičemž vstupem bude datová sada California Housings:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import VarianceThreshold
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import fetch_california_housing
# nacteni datove sady
housings = fetch_california_housing()
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
# tvar puvodni datove sady (pocet zaznamu a atributu) pred vyberem
print("Data shape before selection:")
print(data.shape)
# provest filtering dat
sel = VarianceThreshold(threshold=0.6)
selected = sel.fit_transform(data)
# tvar upravene datove sady (pocet zaznamu a atributu)
print("Data shape after selection:")
print(selected.shape)
Tento skript po svém spuštění zobrazí tvar původní datové sady (20640 záznamů, každý s osmi atributy) a nově redukované datové sady (stejný počet záznamů, ale jen sedm atributů):
Data shape before selection: (20640, 8) Data shape after selection: (20640, 7)
5. Získání jmen atributů původní datové sady a datové sady redukované
V praxi je pochopitelně vhodné zjistit nejenom to, kolik atributů má nově vyfiltrovaná datová sada, ale i to, o jaké atributy se jedná. I tuto informaci lze velmi snadno zjistit pomocí get_feature_names_out:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import VarianceThreshold
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import fetch_california_housing
# nacteni datove sady
housings = fetch_california_housing()
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
# jmena jednotlivych atributu
feature_names = housings["feature_names"]
# tvar puvodni datove sady (pocet zaznamu a atributu) pred vyberem
print("Data shape before selection:")
print(data.shape)
# jmena vsech puvodnich atributu
print("Features before selection:")
print(feature_names)
print()
sel = VarianceThreshold(threshold=0.6)
selected = sel.fit_transform(data)
# tvar upravene datove sady (pocet zaznamu a atributu)
print("Data shape after selection:")
print(selected.shape)
# jmena vybranych atributu
print("Features after selection:")
print(sel.get_feature_names_out(input_features=housings["feature_names"]))
A takto bude vypadat výsledek běhu tohoto skriptu:
Data shape before selection: (20640, 8) Features before selection: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude'] Data shape after selection: (20640, 7) Features after selection: ['MedInc' 'HouseAge' 'AveRooms' 'Population' 'AveOccup' 'Latitude' 'Longitude']
6. Výběr (filtrace) atributů pro různé mezní hodnoty (threshold)
Pokusme se pro zajímavost manipulovat s hodnotou předávanou v parametru threshold. Jedná se o mezní hodnotu pro filtraci atributů na základě jejich rozptylu. Čím větší bude mezní hodnota, tím větší počet atributů bude obecně odstraněn. Vyzkoušejme si nyní proměnnou hodnotu threshold použít společně s datovou sadou Iris:
import numpy as np
# import tridy realizujici vyber atributu
from sklearn.feature_selection import VarianceThreshold
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import load_iris
# nacteni datove sady
iris = load_iris()
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = iris["data"]
# jmena jednotlivych atributu
feature_names = iris["feature_names"]
# tvar puvodni datove sady (pocet zaznamu a atributu) pred vyberem
print("Data shape before selection:")
print(data.shape)
# jmena vsech puvodnich atributu
print("Features before selection:")
print(feature_names)
print()
for threshold in np.linspace(0.0, 1.0, 11):
sel = VarianceThreshold(threshold=threshold)
selected = sel.fit_transform(data)
print(threshold, selected.shape, sel.get_feature_names_out(input_features=feature_names))
Po spuštění skriptu se budou vypisovat tvary datové sady po filtraci, pochopitelně společně s názvy atributů, které v nově sadě zůstaly:
Data shape before selection: (150, 4) Features before selection: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] 0.0 (150, 4) ['sepal length (cm)' 'sepal width (cm)' 'petal length (cm)' 'petal width (cm)'] 0.1 (150, 4) ['sepal length (cm)' 'sepal width (cm)' 'petal length (cm)' 'petal width (cm)'] 0.2 (150, 3) ['sepal length (cm)' 'petal length (cm)' 'petal width (cm)'] 0.3 (150, 3) ['sepal length (cm)' 'petal length (cm)' 'petal width (cm)'] 0.4 (150, 3) ['sepal length (cm)' 'petal length (cm)' 'petal width (cm)'] 0.5 (150, 3) ['sepal length (cm)' 'petal length (cm)' 'petal width (cm)'] 0.6 (150, 2) ['sepal length (cm)' 'petal length (cm)'] 0.7 (150, 1) ['petal length (cm)'] 0.8 (150, 1) ['petal length (cm)'] 0.9 (150, 1) ['petal length (cm)'] 1.0 (150, 1) ['petal length (cm)']
7. Výběr K nejvhodnějších atributů pro trénink
Dalším typem filtrů, který je možné použít pro výběr nejvhodnějších atributů, je filtr nazvaný SelectKBest. Jak již název tohoto filtru naznačuje, bude se vracet K nejlepších atributů, přičemž ona konstanta K je volitelná uživatelem. Ukažme si nejdříve použití tohoto filtru nad datovou sadou Iris, z níž se pokusíme vybrat dva nejlepší atributy:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import load_iris
# nacteni datove sady
iris = load_iris()
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = iris["data"]
# jmena jednotlivych atributu
feature_names = iris["feature_names"]
# tvar puvodni datove sady (pocet zaznamu a atributu) pred vyberem
print("Data shape before selection:")
print(data.shape)
# provest filtering dat
sel = SelectKBest(f_classif, k=2)
selected = sel.fit_transform(data, iris["target"])
# tvar upravene datove sady (pocet zaznamu a atributu)
print("Data shape after selection:")
print(selected.shape)
print(sel.get_feature_names_out(input_features=iris["feature_names"]))
Nejdříve se opět zobrazí tvar (shape) původní datové sady a posléze tvar sady vyfiltrované. A nakonec se vypíše dvojice atributů, která je podle tohoto filtru nejlepší:
Data shape before selection: (150, 4) Data shape after selection: (150, 2) ['petal length (cm)' 'petal width (cm)']
0.6 (150, 2) ['sepal length (cm)' 'petal length (cm)']
8. Výběr čtyř nejvhodnějších atributů datové sady California Housings
Stejný filtr, pouze s odlišnou hodnotou K, nyní použijeme pro výběr atributů z datové sady California Housings. Skript, který tento výběr provede, vypadá následovně:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import fetch_california_housing
# nacteni datove sady
housings = fetch_california_housing()
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
# jmena jednotlivych atributu
feature_names = housings["feature_names"]
# tvar puvodni datove sady (pocet zaznamu a atributu) pred vyberem
print("Data shape before selection:")
print(data.shape)
# provest filtering dat
sel = SelectKBest(f_classif, k=4)
selected = sel.fit_transform(data, housings["target"])
# tvar upravene datove sady (pocet zaznamu a atributu)
print("Data shape after selection:")
print(selected.shape)
print(sel.get_feature_names_out(input_features=housings["feature_names"]))
Výsledkem bude doporučení čtyř atributů vypsaných na posledním řádku:
Data shape before selection: (20640, 8) Data shape after selection: (20640, 4) ['MedInc' 'HouseAge' 'Population' 'Latitude']
9. Výběr atributů pro postupně rostoucí hodnotu K
Samozřejmě si můžeme otestovat, jaké konkrétní atributy budou vybrány v případě, že K předávané do konstruktoru třídy SelectKBest postupně poroste od nuly do maximálního počtu atributů (tedy v našem případě pro osm atributů). Samotný test chování SelectKBest pro proměnné K lze naprogramovat velmi snadno:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import fetch_california_housing
# nacteni datove sady
housings = fetch_california_housing()
# precteni dat z datove sady
# urcenych pro trenink, validaci atd.
data = housings["data"]
# jmena jednotlivych atributu
feature_names = housings["feature_names"]
# tvar puvodni datove sady (pocet zaznamu a atributu) pred vyberem
print("Data shape before selection:")
print(data.shape)
for k_best in range(0, len(feature_names)+1):
# provest filtering dat
sel = SelectKBest(f_classif, k=k_best)
selected = sel.fit_transform(data, housings["target"])
print(k_best, selected.shape, sel.get_feature_names_out(input_features=feature_names))
Podívejme se nyní na výsledky, od „nejlepší malé skupiny“ atributů až po všechny dostupné atributy:
0 (20640, 0) [] 1 (20640, 1) ['MedInc'] 2 (20640, 2) ['MedInc' 'Latitude'] 3 (20640, 3) ['MedInc' 'Population' 'Latitude'] 4 (20640, 4) ['MedInc' 'HouseAge' 'Population' 'Latitude'] 5 (20640, 5) ['MedInc' 'HouseAge' 'Population' 'Latitude' 'Longitude'] 6 (20640, 6) ['MedInc' 'HouseAge' 'AveRooms' 'Population' 'Latitude' 'Longitude'] 7 (20640, 7) ['MedInc' 'HouseAge' 'AveRooms' 'AveBedrms' 'Population' 'Latitude' 'Longitude'] 8 (20640, 8) ['MedInc' 'HouseAge' 'AveRooms' 'AveBedrms' 'Population' 'AveOccup' 'Latitude' 'Longitude']
10. Použití modelu pro výběr atributů
Výběr atributů vhodných (či dokonce nejlepších) pro trénink určitého modelu nemusí být proveden pouze na základě prostých statistických informací, ale můžeme k této operaci použít k tomu určené modely a především pak třídu SelectFromModel, která zajistí výběr modelu:
class SelectFromModel(sklearn.base.MetaEstimatorMixin, sklearn.feature_selection._base.SelectorMixin, sklearn.base.BaseEstimator) | SelectFromModel(estimator, *, threshold=None, prefit=False, norm_order=1, max_features=None, importance_getter='auto') | | Meta-transformer for selecting features based on importance weights. | | .. versionadded:: 0.17 | | Read more in the :ref:`User Guide <select_from_model>`. | | Parameters | ---------- | estimator : object | The base estimator from which the transformer is built. | This can be both a fitted (if ``prefit`` is set to True) | or a non-fitted estimator. The estimator should have a | ``feature_importances_`` or ``coef_`` attribute after fitting. | Otherwise, the ``importance_getter`` parameter should be used. |
Povšimněte si, že v prvním parametru konstruktoru této třídy se předává takzvaný estimator neboli „odhadovač výsledků“. Výsledkem je instance modelu:
# "odhadovac" vysledku lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X, y) # vyber modelu model = SelectFromModel(lsvc, prefit=True)
Vybraný model můžeme následně použít pro výběr atributů a popř. i natrénování:
# transformace dat X_new = model.transform(X) # natrenovani modelu model.fit(X, y)
11. Ukázka využití modelu pro výběr atributů
Opět si na praktickém příkladu vyzkoušejme, jakým způsobem je možné použít model pro výběr atributů. Konkrétně využijeme třídy LinearSVC a SelectFromModel. Instance třídy LinearSVC bude využita pro odhad výsledků, návratová hodnota bude použita modelem pro výběr atributů. Model následně ztransformuje původní datovou sadu na sadu novou:
from sklearn.svm import LinearSVC # import funkce pro nacteni datove sady, kterou pouzijeme from sklearn.datasets import load_iris from sklearn.feature_selection import SelectFromModel # nacteni datove sady iris = load_iris() # ziskani atributu a ocekavanych vysledku X = iris["data"] y = iris["target"] # jmena jednotlivych atributu feature_names = iris["feature_names"] # "odhadovac" vysledku lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X, y) # vyber modelu model = SelectFromModel(lsvc, prefit=True) # tisk modelu print(model) # transformace dat X_new = model.transform(X) # natrenovani modelu model.fit(X, y) # vysledek + ziskani jmen atributu, ktere se pouzily print(X_new.shape) print(model.get_feature_names_out(input_features=feature_names))
Zkontrolujeme výsledky vyprodukované tímto skriptem. Nyní byly pro trénink modelu vybrány tři atributy, které jsou vypsány na posledním řádku:
SelectFromModel(estimator=LinearSVC(C=0.01, dual=False, penalty='l1'),
prefit=True)
(150, 3)
['sepal length (cm)' 'sepal width (cm)' 'petal length (cm)']
12. Křížová validace modelu naučeného s využitím vyfiltrované skupiny atributů
Ve chvíli, kdy se vybírá model, upravují se hyperparametry modelu, popř. když se filtrují vstupní atributy, je prakticky vždy dobré provést křížovou validaci. Již minule jsme si ukázali způsoby provedení křížové validace při výběru modelů a při nastavování jejich hyperparametrů. Zbývá nám jediné – ukázat si kombinaci filtraci atributů s křížovou validací. Nejedná se o nijak komplikované programy, protože již všechny potřebné třídy a funkce známe. Jen pro úplnost si v navazujících kapitolách ukážeme konkrétní postupy, a to opět na našich dvou testovacích datových sadách: Iris a California Housings.
13. Křížová validace pro model natrénovaný na datovou sadu Iris
Nejprve si ukažme provedení křížové validace pro datovou sadu Iris, z níž postupně vybíráme 1 až 4 nejlepší atributy. Bude nás zajímat, pro jakou kombinaci atributů bude natrénovaný model odhadovat nejlepší výsledky:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif
from sklearn.neighbors import KNeighborsClassifier
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
# nacteni datove sady
iris = load_iris()
# jmena jednotlivych atributu
feature_names = iris["feature_names"]
# X je matice (feature matrix)
X = iris.data
# y je vektor (response vector)
y = iris.target
for k_best in range(1, len(feature_names)+1):
# provest filtering dat
sel = SelectKBest(f_classif, k=k_best)
X_new = sel.fit_transform(X, y)
print(k_best, X_new.shape, sel.get_feature_names_out(input_features=feature_names))
# konstrukce klasifikatoru
knn = KNeighborsClassifier(n_neighbors=5)
scores = cross_val_score(knn, X_new, y, cv=10, scoring='accuracy')
print("Average score:", scores.mean())
14. Výsledky křížové validace pro datovou sadu Iris
Výsledky získané skriptem uvedeným v předchozí kapitole by měly vypadat následovně:
1 (150, 1) ['petal length (cm)'] Average score: 0.9533333333333334 2 (150, 2) ['petal length (cm)' 'petal width (cm)'] Average score: 0.9666666666666666 3 (150, 3) ['sepal length (cm)' 'petal length (cm)' 'petal width (cm)'] Average score: 0.96 4 (150, 4) ['sepal length (cm)' 'sepal width (cm)' 'petal length (cm)' 'petal width (cm)'] Average score: 0.9666666666666668
15. Křížová validace pro model natrénovaný na datovou sadu California Housings
Prakticky totožným způsobem lze zkombinovat výběr atributů s využitím SelectKBest a s ověřením natrénovaného modelu LinearRegression křížovou validací. Jak je již z názvu modelu patrné, použijeme nyní datovou sadu California Housings a necháme model odhadovat cenu nemovitosti:
# import tridy realizujici vyber atributu
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif
from sklearn import linear_model
# import funkce pro nacteni datove sady, kterou pouzijeme
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
# nacteni datove sady
housings = fetch_california_housing()
# jmena jednotlivych atributu
feature_names = housings["feature_names"]
# X je matice (feature matrix)
X = housings.data
# y je vektor (response vector)
y = housings.target
for k_best in range(1, len(feature_names)+1):
# provest filtering dat
sel = SelectKBest(f_classif, k=k_best)
X_new = sel.fit_transform(X, y)
# konstrukce modelu pro regresi
lr = linear_model.LinearRegression()
scores = cross_val_score(lr, X_new, y, cv=10, scoring='r2')
print(k_best, X_new.shape, sel.get_feature_names_out(input_features=feature_names), scores.mean())
16. Výsledky křížové validace pro datovou sadu California housings
Pro datovou sadu California Housings a pro proměnný počet atributů použitých pro trénink modelu vypadají výsledky křížové validace následovně:
1 (20640, 1) ['MedInc'] 0.3483800124754965 2 (20640, 2) ['MedInc' 'Latitude'] 0.34861270211722617 3 (20640, 3) ['MedInc' 'Population' 'Latitude'] 0.34993815052254296 4 (20640, 4) ['MedInc' 'HouseAge' 'Population' 'Latitude'] 0.3903572524665514 5 (20640, 5) ['MedInc' 'HouseAge' 'Population' 'Latitude' 'Longitude'] 0.5021339726461409 6 (20640, 6) ['MedInc' 'HouseAge' 'AveRooms' 'Population' 'Latitude' 'Longitude'] 0.5034342766060689 7 (20640, 7) ['MedInc' 'HouseAge' 'AveRooms' 'AveBedrms' 'Population' 'Latitude' 'Longitude'] 0.5100561354984194 8 (20640, 8) ['MedInc' 'HouseAge' 'AveRooms' 'AveBedrms' 'Population' 'AveOccup' 'Latitude' 'Longitude'] 0.5110068610523775
17. Výsledky křížové validace pro filtraci pomocí VarianceThreshold
Na závěr si ještě ukážeme výsledky křížové validace ve chvíli, kdy byla filtrace provedena s využitím filtru VarianceThreshold; zde konkrétně pro datovou sadu California Housings. Skript, který provede příslušný výpočet, vypadá následovně:
# import tridy realizujici vyber atributu from sklearn.feature_selection import VarianceThreshold from sklearn import linear_model # import funkce pro nacteni datove sady, kterou pouzijeme from sklearn.datasets import fetch_california_housing from sklearn.model_selection import cross_val_score # nacteni datove sady housings = fetch_california_housing() # jmena jednotlivych atributu feature_names = housings["feature_names"] # X je matice (feature matrix) X = housings.data # y je vektor (response vector) y = housings.target sel = VarianceThreshold(threshold=0.6) X_new = sel.fit_transform(X, y) # konstrukce modelu pro regresi lr = linear_model.LinearRegression() scores = cross_val_score(lr, X_new, y, cv=10, scoring='r2') print(X_new.shape, sel.get_feature_names_out(input_features=feature_names), scores.mean())
A takto konkrétně bude vypadat výsledek křížové validace ve chvíli, kdy byl z původní datové sady odstraněn jeden z atributů, takže se namísto osmi atributů použilo pouze atributů sedm:
20640, 7) ['MedInc' 'HouseAge' 'AveRooms' 'Population' 'AveOccup' 'Latitude' 'Longitude'] 0.503734153650471
18. Obsah navazujícího článku – neuronové sítě
V navazujícím článku se budeme zabývat pravděpodobně nejpopulárnější skupinou modelů. Bude se jednat o modely založené na neuronových sítích. Knihovna scikit-learn v této oblasti nabízí jak varianty neuronových sítí provádějících klasifikaci, tak i neuronové sítě, které dokážou provádět regresi. A pochopitelně je možné (i když jen do určité míry) ovlivnit interní strukturu neuronové sítě, tj. zejména počet takzvaných skrytých vrstev i počet neuronů v jednotlivých skrytých vrstvách, použitou aktivační funkci atd. A vzhledem k tomu, že se z pohledu scikit-learn stále jedná o „standardní“ modely, budeme mít k dispozici všechny již popsané nástroje pro trénink, validaci, testování, křížovou validaci atd.
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:
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/pyproject.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/Rozpozná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/particle_life.py |
20. Odkazy na Internetu
- Shluková analýza (clustering) a knihovna Scikit-learn
https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn/ - Shluková analýza (clustering) a knihovna Scikit-learn (2)
https://www.root.cz/clanky/shlukova-analyza-clustering-a-knihovna-scikit-learn-2/ - 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/ - Rozpoznávání obrázků knihovnou Scikit-learn: první kroky
https://www.root.cz/clanky/rozpoznavani-obrazku-knihovnou-scikit-learn-prvni-kroky/ - scikit-learn: Machine Learning in Python
https://scikit-learn.org/stable/index.html - Sklearn-pandas
https://github.com/scikit-learn-contrib/sklearn-pandas - sklearn-xarray
https://github.com/phausamann/sklearn-xarray/ - Clustering
https://scikit-learn.org/stable/modules/clustering.html - Cluster analysis (Wikipedia)
https://en.wikipedia.org/wiki/Cluster_analysis - Shluková analýza (Wikipedia)
https://cs.wikipedia.org/wiki/Shlukov%C3%A1_anal%C3%BDza - K-means
https://cs.wikipedia.org/wiki/K-means - k-means clustering
https://en.wikipedia.org/wiki/K-means_clustering - Spectral clustering
https://en.wikipedia.org/wiki/Spectral_clustering - Emergence
https://cs.wikipedia.org/wiki/Emergence - Particle Life: Vivid structures from rudimentary rules
https://particle-life.com/ - Hertzsprungův–Russellův diagram
https://cs.wikipedia.org/wiki/Hertzsprung%C5%AFv%E2%80%93Russell%C5%AFv_diagram - Using Machine Learning in an HR Diagram
https://cocalc.com/share/public_paths/08b6e03583cbdef3cdb9813a54ec68ff773c747f - Gaia H-R diagrams: Querying Gaia data for one million nearby stars
https://vlas.dev/post/gaia-dr2-hrd/ - The Hertzsprung–Russell diagram
https://scipython.com/book2/chapter-9-data-analysis-with-pandas/problems/p92/the-hertzsprung-russell-diagram/ - Animated Hertzsprung-Russell Diagram with 119,614 datapoints
https://github.com/zonination/h-r-diagram - Neuraxle Pipelines
https://github.com/Neuraxio/Neuraxle - scikit-learn: Getting Started
https://scikit-learn.org/stable/getting_started.html - Support Vector Machines
https://scikit-learn.org/stable/modules/svm.html - Use Deep Learning to Detect Programming Languages
http://searene.me/2017/11/26/use-neural-networks-to-detect-programming-languages/ - Natural-language processing
https://en.wikipedia.org/wiki/Natural-language_processing - THE MNIST DATABASE of handwritten digits
http://yann.lecun.com/exdb/mnist/ - MNIST database (Wikipedia)
https://en.wikipedia.org/wiki/MNIST_database - MNIST For ML Beginners
https://www.tensorflow.org/get_started/mnist/beginners - Stránka projektu Torch
http://torch.ch/ - Torch: Serialization
https://github.com/torch/torch7/blob/master/doc/serialization.md - Torch: modul image
https://github.com/torch/image/blob/master/README.md - Data pro neuronové sítě
http://archive.ics.uci.edu/ml/index.php - Torch na GitHubu (několik repositářů)
https://github.com/torch - Torch (machine learning), Wikipedia
https://en.wikipedia.org/wiki/Torch_%28machine_learning%29 - Torch Package Reference Manual
https://github.com/torch/torch7/blob/master/README.md - Torch Cheatsheet
https://github.com/torch/torch7/wiki/Cheatsheet - Neural network containres (Torch)
https://github.com/torch/nn/blob/master/doc/containers.md - Simple layers
https://github.com/torch/nn/blob/master/doc/simple.md#nn.Linear - Transfer Function Layers
https://github.com/torch/nn/blob/master/doc/transfer.md#nn.transfer.dok - Feedforward neural network
https://en.wikipedia.org/wiki/Feedforward_neural_network - Biologické algoritmy (4) – Neuronové sítě
https://www.root.cz/clanky/biologicke-algoritmy-4-neuronove-site/ - Biologické algoritmy (5) – Neuronové sítě
https://www.root.cz/clanky/biologicke-algoritmy-5-neuronove-site/ - Umělá neuronová síť (Wikipedia)
https://cs.wikipedia.org/wiki/Um%C4%9Bl%C3%A1_neuronov%C3%A1_s%C3%AD%C5%A5 - PyTorch
http://pytorch.org/ - JupyterLite na PyPi
https://pypi.org/project/jupyterlite/ - JupyterLite na GitHubu
https://github.com/jupyterlite/jupyterlite - Dokumentace k projektu JupyterLite
https://github.com/jupyterlite/jupyterlite - Matplotlib Home Page
http://matplotlib.org/ - Matplotlib (Wikipedia)
https://en.wikipedia.org/wiki/Matplotlib - Popis barvových map modulu matplotlib.cm
https://gist.github.com/endolith/2719900#id7 - Ukázky (palety) barvových map modulu matplotlib.cm
http://matplotlib.org/examples/color/colormaps_reference.html - Galerie grafů vytvořených v Matplotlibu
https://matplotlib.org/3.2.1/gallery/ - 3D rendering
https://en.wikipedia.org/wiki/3D_rendering - 3D computer graphics
https://en.wikipedia.org/wiki/3D_computer_graphics - Primary 3D view planes
https://matplotlib.org/stable/gallery/mplot3d/view_planes_3d.html - Getting started in scikit-learn with the famous iris dataset
https://www.youtube.com/watch?v=hd1W4CyPX58 - Training a machine learning model with scikit-learn
https://www.youtube.com/watch?v=RlQuVL6-qe8 - Iris (plant)
https://en.wikipedia.org/wiki/Iris_(plant) - Kosatec
https://cs.wikipedia.org/wiki/Kosatec - Iris setosa
https://en.wikipedia.org/wiki/Iris_setosa - Iris versicolor
https://en.wikipedia.org/wiki/Iris_versicolor - Iris virginica
https://en.wikipedia.org/wiki/Iris_virginica - Druh
https://cs.wikipedia.org/wiki/Druh - Iris subg. Limniris
https://en.wikipedia.org/wiki/Iris_subg._Limniris - Iris Dataset Classification with Python: A Tutorial
https://www.pycodemates.com/2022/05/iris-dataset-classification-with-python.html - Iris flower data set
https://en.wikipedia.org/wiki/Iris_flower_data_set - List of datasets for machine-learning research
https://en.wikipedia.org/wiki/List_of_datasets_for_machine-learning_research - Analýza hlavních komponent
https://cs.wikipedia.org/wiki/Anal%C3%BDza_hlavn%C3%ADch_komponent - Principal component analysis
https://en.wikipedia.org/wiki/Principal_component_analysis - Scikit-learn Crash Course – Machine Learning Library for Python
https://www.youtube.com/watch?v=0B5eIE_1vpU - calm-notebooks
https://github.com/koaning/calm-notebooks - Should you teach Python or R for data science?
https://www.dataschool.io/python-or-r-for-data-science/ - nbviewer: A simple way to share Jupyter Notebooks
https://nbviewer.org/ - AI vs Machine Learning (Youtube)
https://www.youtube.com/watch?v=4RixMPF4×is - Machine Learning | What Is Machine Learning? | Introduction To Machine Learning | 2024 | Simplilearn (Youtube)
https://www.youtube.com/watch?v=ukzFI9rgwfU - A Gentle Introduction to Machine Learning (Youtube)
https://www.youtube.com/watch?v=Gv9_4yMHFhI - Machine Learning vs Deep Learning
https://www.youtube.com/watch?v=q6kJ71tEYqM - Umělá inteligence (slajdy)
https://slideplayer.cz/slide/12119218/ - Úvod do umělé inteligence
https://slideplayer.cz/slide/2505525/ - Umělá inteligence I / Artificial Intelligence I
https://ktiml.mff.cuni.cz/~bartak/ui/ - 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/ - Matplotlib, Seaborn or Plotnine?
https://www.reddit.com/r/datascience/comments/jvrqxt/matplotlib_seaborn_or_plotnine/ - @Rabeez: Rabeez/plotting_comparison.ipynb
https://gist.github.com/Rabeez/ffc0b59d4a41e20fa8d944c44a96adbc - Matplotlib, Seaborn, Plotly and Plotnine Comparison
https://python.plainenglish.io/matplotlib-seaborn-plotly-and-plotnine-comparison-baf2db5a9c40 - Data Visualization 101: How to Choose a Python Plotting Library
https://towardsdatascience.com/data-visualization-101-how-to-choose-a-python-plotting-library-853460a08a8a - Data science in Python: pandas, seaborn, scikit-learn
https://www.youtube.com/watch?v=3ZWuPVWq7p4 - 7.2. Real world datasets
https://scikit-learn.org/stable/datasets/real_world.html#california-housing-dataset - 7.2.7. California Housing dataset
https://scikit-learn.org/stable/datasets/real_world.html#california-housing-dataset - Comprehensive Guide to Classification Models in Scikit-Learn
https://www.geeksforgeeks.org/comprehensive-guide-to-classification-models-in-scikit-learn/ - Tidy Data Visualization: ggplot2 vs seaborn
https://blog.tidy-intelligence.com/posts/ggplot2-vs-seaborn/ - seaborn: statistical data visualization
https://seaborn.pydata.org/ - Linear regression (Wikipedia)
https://en.wikipedia.org/wiki/Linear_regression - Lineární regrese (Wikipedia)
https://cs.wikipedia.org/wiki/Line%C3%A1rn%C3%AD_regrese - Iris Flower Classification with MLP Classifier
https://www.metriccoders.com/post/iris-flower-classification-with-mlp-classifier
