11.1. Modele sprawdzianu krzyżowego

# Wczytanie bibliotek.
from sklearn import datasets
from sklearn import metrics
from sklearn.model_selection import KFold, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

# Wczytanie zbioru danych w postaci liczb.
digits = datasets.load_digits()

# Utworzenie macierzy cech.
features = digits.data

# Utworzenie wektora docelowego.
target = digits.target

# Utworzenie egzemplarza StandardScaler.
standardizer = StandardScaler()

# Utworzenie obiektu regresji logistycznej.
logit = LogisticRegression()

# Utworzenie potoku standaryzującego, a następnie przeprowadzającego regresję logistyczną.
pipeline = make_pipeline(standardizer, logit)

# Zdefiniowanie k-krotnego sprawdzianu krzyżowego.
kf = KFold(n_splits=5, shuffle=True, random_state=0)

# Przeprowadzenie k-krotnego sprawdzianu krzyżowego.
cv_results = cross_val_score(pipeline, # Potok.
                             features, # Macierz cech.
                             target, # Wektor docelowy.
                             cv=kf, # Technika sprawdzianu krzyżowego.
                             scoring="accuracy", # Funkcja straty.
                             n_jobs=-1) # Użycie wszystkich dostępnych rdzeni procesora.

# Obliczenie średniej.
cv_results.mean()

0.969958217270195





# Wyświetlenie wyniku dla wszystkich pięciu podzbiorów.
cv_results

array([0.96111111, 0.96388889, 0.98050139, 0.97214485, 0.97214485])





# Wczytanie biblioteki.
from sklearn.model_selection import train_test_split

# Utworzenie zbiorów uczącego i testowego.
features_train, features_test, target_train, target_test = train_test_split(
    features, target, test_size=0.1, random_state=1)

# Wywołanie fit() w zbiorze uczącym.
standardizer.fit(features_train)

# Przeprowadzenie przekształcenia w obu zbiorach, uczącym i testowym.
features_train_std = standardizer.transform(features_train)
features_test_std = standardizer.transform(features_test)





# Utworzenie potoku.
pipeline = make_pipeline(standardizer, logit)





# Przeprowadzenie k-krotnego sprawdzianu krzyżowego.
cv_results = cross_val_score(pipeline, # Potok.
                             features, # Macierz cech.
                             target, # Wektor docelowy.
                             cv=kf, # Technika sprawdzianu krzyżowego.
                             scoring="accuracy", # Funkcja straty.
                             n_jobs=-1) # Użycie wszystkich dostępnych rdzeni procesora.





11.2. Tworzenie modelu regresji bazowej

# Wczytanie bibliotek.
from sklearn.datasets import load_wine
from sklearn.dummy import DummyRegressor
from sklearn.model_selection import train_test_split

# Wczytanie danych.
wine = load_wine()

# Utworzenie cech.
features, target = wine.data, wine.target

# Podział na zbiory uczący i testowy.
features_train, features_test, target_train, target_test = train_test_split(
    features, target, random_state=0)

# Utworzenie sztucznego regresora.
dummy = DummyRegressor(strategy='mean')

# "Wytrenowanie" sztucznego regresora.
dummy.fit(features_train, target_train)

# Pobranie kwadratu wartości.
dummy.score(features_test, target_test)

-0.0480213580840978





# Wczytanie biblioteki.
from sklearn.linear_model import LinearRegression

# Wytrenowanie prostego modelu regresji liniowej.
ols = LinearRegression()
ols.fit(features_train, target_train)

# Pobranie kwadratu wartości.
ols.score(features_test, target_test)

0.804353263176954





# Utworzenie sztucznego regresora prognozującego wartość 1 dla wszystkiego.
clf = DummyRegressor(strategy='constant', constant=1)
clf.fit(features_train, target_train)

# Ocena modelu.
clf.score(features_test, target_test)

-0.06299212598425186





11.3. Tworzenie modelu klasyfikacji bazowej

# Wczytanie bibliotek.
from sklearn.datasets import load_iris
from sklearn.dummy import DummyClassifier
from sklearn.model_selection import train_test_split

# Wczytanie danych.
iris = load_iris()

# Utworzenie wektora docelowego i macierzy cech.
features, target = iris.data, iris.target

# Podział na zbiory uczący i testowy.
features_train, features_test, target_train, target_test = train_test_split(
    features, target, random_state=0)

# Utworzenie sztucznego klasyfikatora.
dummy = DummyClassifier(strategy='uniform', random_state=1)

# "Wytrenowanie" modelu.
dummy.fit(features_train, target_train)

# Pobranie wyniku dokładności.
dummy.score(features_test, target_test)

0.42105263157894735





# Wczytanie biblioteki.
from sklearn.ensemble import RandomForestClassifier

# Utworzenie klasyfikatora.
classifier = RandomForestClassifier()

# Wytrenowanie modelu.
classifier.fit(features_train, target_train)

# Pobranie wyniku dokładności.
classifier.score(features_test, target_test)

0.9736842105263158





11.4. Ocena prognoz klasyfikatora binarnego

# Wczytanie bibliotek.
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

# Wygenerowanie macierzy cech i wektora docelowego.
X, y = make_classification(n_samples = 10000,
                           n_features = 3,
                           n_informative = 3,
                           n_redundant = 0,
                           n_classes = 2,
                           random_state = 1)

# Utworzenie regresji logistycznej.
logit = LogisticRegression()

# Model sprawdzianu krzyżowego weryfikującego dokładność.
cross_val_score(logit, X, y, scoring="accuracy")

array([0.9555, 0.95  , 0.9585, 0.9555, 0.956])





# Model sprawdzianu krzyżowego weryfikującego precyzję.
cross_val_score(logit, X, y, scoring="precision")

array([0.95963673, 0.94820717, 0.9635996 , 0.96149949, 0.96060606])





# Model sprawdzianu krzyżowego weryfikującego pełność.
cross_val_score(logit, X, y, scoring="recall")

array([0.951, 0.952, 0.953, 0.949, 0.951])





# Model sprawdzianu krzyżowego weryfikującego wartość F1.
cross_val_score(logit, X, y, scoring="f1")

array([0.95529884, 0.9500998 , 0.95827049, 0.95520886, 0.95577889])





# Wczytanie biblioteki.
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Podział na zbiory uczący i testowy.
X_train, X_test, y_train, y_test = train_test_split(X,
                                                    y,
                                                    test_size=0.1,
                                                    random_state=1)

# Prognozowanie wartości dla wektora docelowego zbioru uczącego.
y_hat = logit.fit(X_train, y_train).predict(X_test)

# Obliczenie dokładności.
accuracy_score(y_test, y_hat)

0.947
Zobacz również





11.5. Ocena progowania klasyfikatora binarnego

# Wczytanie bibliotek.
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_curve, roc_auc_score
from sklearn.model_selection import train_test_split

# Utworzenie macierzy cech i wektora docelowego.
features, target = make_classification(n_samples=10000,
                                       n_features=10,
                                       n_classes=2,
                                       n_informative=3,
                                       random_state=3)

# Podział na zbiory uczący i testowy.
features_train, features_test, target_train, target_test = train_test_split(
    features, target, test_size=0.1, random_state=1)

# Utworzenie klasyfikatora.
logit = LogisticRegression()

# Wytrenowanie modelu.
logit.fit(features_train, target_train)

# Pobranie prognozowanego prawdopodobieństwa.
target_probabilities = logit.predict_proba(features_test)[:,1]

# Utworzenie współczynników prawdziwie i fałszywie pozytywnych.
false_positive_rate, true_positive_rate, threshold = roc_curve(
    target_test,
    target_probabilities
)

# Wyświetlenie krzywej ROC.
plt.title("Krzywa ROC")
plt.plot(false_positive_rate, true_positive_rate)
plt.plot([0, 1], ls="--")
plt.plot([0, 0], [1, 0] , c=".7"), plt.plot([1, 1] , c=".7")
plt.ylabel("Współczynnik wartości prawdziwie pozytywnych")
plt.xlabel("Współczynnik wartości fałszywie pozytywnych")
plt.show()





# Pobranie prognozowanego prawdopodobieństwa.
logit.predict_proba(features_test)[0:1]

array([[0.86891533, 0.13108467]])





logit.classes_

array([0, 1])





print("Wartość progowa:", threshold[124])
print("Współczynnik wartości prawdziwie pozytywnych:", true_positive_rate[124])
print("Współczynnik wartości fałszywie pozytywnych:", false_positive_rate[124])

Wartość progowa: 0.5008252732632008
Współczynnik wartości prawdziwie pozytywnych: 0.8346938775510204
Współczynnik wartości fałszywie pozytywnych: 0.1607843137254902





print("Wartość progowa:", threshold[49])
print("Współczynnik wartości prawdziwie pozytywnych:", true_positive_rate[49])
print("Współczynnik wartości fałszywie pozytywnych:", false_positive_rate[49])

Wartość progowa: 0.8058575028551827
Współczynnik wartości prawdziwie pozytywnych: 0.5653061224489796
Współczynnik wartości fałszywie pozytywnych: 0.052941176470588235





# Obliczenie powierzchni pod krzywą ROC.
roc_auc_score(target_test, target_probabilities)

0.9073389355742297





11.6. Ocena prognoz klasyfikatora wieloklasowego

# Wczytanie bibliotek.
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

# Wygenerowanie macierzy cech i wektora docelowego.
features, target = make_classification(n_samples = 10000,
                           n_features = 3,
                           n_informative = 3,
                           n_redundant = 0,
                           n_classes = 3,
                           random_state = 1)

# Utworzenie regresji logistycznej.
logit = LogisticRegression()

# Model sprawdzianu krzyżowego weryfikującego dokładność.
cross_val_score(logit, features, target, scoring='accuracy')

array([0.841 , 0.829 , 0.8265, 0.8155, 0.82])





# Model sprawdzianu krzyżowego używającego makro uśrednionej wartości F1.
cross_val_score(logit, features, target, scoring='f1_macro')

array([0.84061272, 0.82895312, 0.82625661, 0.81515121, 0.81992692])





11.7. Wizualizacja wydajności klasyfikatora

# Wczytanie bibliotek.
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import pandas as pd

# Wczytanie danych.
iris = datasets.load_iris()

# Utworzenie macierzy cech.
features = iris.data

# Utworzenie wektora docelowego.
target = iris.target

# Utworzenie listy klas docelowych.
class_names = iris.target_names

# Utworzenie zbiorów uczącego i testowego.
features_train, features_test, target_train, target_test = train_test_split(
    features, target, random_state=2)

# Utworzenie regresji logistycznej.
classifier = LogisticRegression()

# Wytrenowanie modelu i wygenerowanie prognoz.
target_predicted = classifier.fit(features_train,
    target_train).predict(features_test)

# Utworzenie macierzy pomyłek.
matrix = confusion_matrix(target_test, target_predicted)

# Utworzenie obiektu DataFrame biblioteki pandas.
dataframe = pd.DataFrame(matrix, index=class_names, columns=class_names)

# Utworzenie mapy cieplnej.
sns.heatmap(dataframe, annot=True, cbar=None, cmap="Blues")
plt.title("Macierz pomyłek"), plt.tight_layout()
plt.ylabel("Klasy prawdziwe"), plt.xlabel("Klasy prognozowane")
plt.show()





11.8. Ocena modelu regresji

# Wczytanie bibliotek.
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression

# Wygenerowanie macierzy cech i wektora docelowego.
features, target = make_regression(n_samples = 100,
                                   n_features = 3,
                                   n_informative = 3,
                                   n_targets = 1,
                                   noise = 50,
                                   coef = False,
                                   random_state = 1)

# Utworzenie obiektu regresji liniowej.
ols = LinearRegression()

# Sprawdzian krzyżowy regresji liniowej za pomocą (negatywnego) MSE.
cross_val_score(ols, features, target, scoring='neg_mean_squared_error')

array([-1974.65337976, -2004.54137625, -3935.19355723, -1060.04361386,
           -1598.74104702])





# Sprawdzian krzyżowy regresji liniowej z użyciem R do kwadratu.
cross_val_score(ols, features, target, scoring='r2')

array([0.8622399 , 0.85838075, 0.74723548, 0.91354743, 0.84469331])





11.9. Ocena modelu klasteryzacji

import numpy as np
from sklearn.metrics import silhouette_score
from sklearn import datasets
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

# Wygenerowanie macierzy cech.
features, _ = make_blobs(n_samples = 1000,
                         n_features = 10,
                         centers = 2,
                         cluster_std = 0.5,
                         shuffle = True,
                         random_state = 1)

# Klastrowanie danych za pomocą k-krotności, aby prognozować klasy.
model = KMeans(n_clusters=2, random_state=1).fit(features)

# Pobranie prognozowanych klas.
target_predicted = model.labels_

# Ocena modelu.
silhouette_score(features, target_predicted)

0.8916265564072141





11.10. Definiowanie niestandardowych współczynników oceny modelu

# Wczytanie bibliotek.
from sklearn.metrics import make_scorer, r2_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.datasets import make_regression

# Wygenerowanie macierzy cech i wektora docelowego.
features, target = make_regression(n_samples = 100,
                                   n_features = 3,
                                   random_state = 1)

# Utworzenie zbiorów uczącego i testowego.
features_train, features_test, target_train, target_test = train_test_split(
     features, target, test_size=0.10, random_state=1)

# Zdefiniowanie własnego współczynnika.
def custom_metric(target_test, target_predicted):
    # Obliczenie wartości R kwadrat.
    r2 = r2_score(target_test, target_predicted)
    # Zwrot wartości R kwadrat.
    return r2

# Utworzenie funkcji oceniającej i zdefiniowanie, że im większa wartość zwrotna, tym lepiej.
score = make_scorer(custom_metric, greater_is_better=True)

# Utworzenie obiektu regresji grzbietowej.
classifier = Ridge()

# Wytrenowanie modelu regresji grzbietowej.
model = classifier.fit(features_train, target_train)

# Zastosowanie własnej funkcji oceniającej.
score(model, features_test, target_test)

0.9997906102882058





# Wartości prognozowane.
target_predicted = model.predict(features_test)

# Obliczenie wartości R kwadrat.
r2_score(target_test, target_predicted)

0.9997906102882058





11.11. Wizualizacja efektu wywieranego przez wielkość zbioru uczącego

# Wczytanie bibliotek.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import learning_curve

# Wczytanie danych.
digits = load_digits()

# Utworzenie macierzy cech i wektora docelowego.
features, target = digits.data, digits.target

# Zdefiniowanie sprawdzianu krzyżowego zbiorów uczącego i testowego dla ich różnych wielkości.
train_sizes, train_scores, test_scores = learning_curve(# Klasyfikator.
                                                        RandomForestClassifier(),
                                                        # Macierz cech.
                                                        features,
                                                        # Wektor docelowy.
                                                        target,
                                                        # Liczba podzbiorów.
                                                        cv=10,
                                                        # Wskaźnik wydajności.
                                                        scoring='accuracy',
                                                        # Użycie wszystkich rdzeni procesora.
                                                        n_jobs=-1,
                                                        # Zbiór uczący ma
                                                        # wielkość 50.
                                                       train_sizes=np.linspace(
                                                       0.01,
                                                       1.0,
                                                       50))

# Obliczenie średniej i odchylenia standardowego dla wyników zbioru uczącego.
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)

# Obliczenie średniej i odchylenia standardowego dla wyników zbioru testowego.
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)

# Wyświetlenie linii.
plt.plot(train_sizes, train_mean, '--', color="#111111", label="Wynik uczenia")
plt.plot(train_sizes, test_mean, color="#111111", label="Wynik sprawdzianu krzyżowego")

# Wyświetlenie opaski.
plt.fill_between(train_sizes, train_mean - train_std,
                 train_mean + train_std, color="#DDDDDD")
plt.fill_between(train_sizes, test_mean - test_std,
                 test_mean + test_std, color="#DDDDDD")

# Wyświetlenie wykresu.
plt.title("Krzywa uczenia")
plt.xlabel("Wielkość zbioru uczącego"), plt.ylabel("Dokładność"),
plt.legend(loc="best")
plt.tight_layout()
plt.show()





11.12. Tworzenie raportu tekstowego dotyczącego współczynnika oceny

# Wczytanie bibliotek.
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Wczytanie danych.
iris = datasets.load_iris()

# Utworzenie macierzy cech.
features = iris.data

# Utworzenie wektora docelowego.
target = iris.target

# Utworzenie listy klas docelowych.
class_names = iris.target_names

# Utworzenie zbiorów uczącego i testowego.
features_train, features_test, target_train, target_test = train_test_split(
    features, target, random_state=0)

# Utworzenie regresji logistycznej.
classifier = LogisticRegression()

# Wytrenowanie modelu i wygenerowanie prognoz.
model = classifier.fit(features_train, target_train)
target_predicted = model.predict(features_test)

# Wygenerowanie raportu klasyfikatora.
print(classification_report(target_test,
                            target_predicted,
                            target_names=class_names))

              precision    recall  f1-score   suport

      setosa       1.00      1.00      1.00        16
  versicolor       1.00      0.91      0.95        11
   virginica       0.92      1.00      0.96         11

    accuracy                           0.97        38
   macro avg       0.97      0.97      0.97        38
weighted avg       0.98      0.97      0.97        38





11.13. Wizualizacja efektu wywieranego przez zmianę wartości hiperparametrów

# Wczytanie bibliotek.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import load_digits
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import validation_curve

# Wczytanie danych.
digits = load_digits()

# Utworzenie macierzy cech i wektora docelowego.
features, target = digits.data, digits.target

# Zdefiniowanie zakresu wartości parametru.
param_range = np.arange(1, 250, 2)

# Obliczenie dokładności zbiorów uczącego i testowego dla zakresu wartości parametru.
train_scores, test_scores = validation_curve(
    # Klasyfikator.
    RandomForestClassifier(),
    # Macierz cech.
    features,
    # Wektor docelowy.
    target,
    # Analizowany hiperparametr.
    param_name="n_estimators",
    # Zakres wartości hiperparametru.
    param_range=param_range,
    # Liczba podzbiorów.
    cv=3,
    # Wskaźnik wydajności.
    scoring="accuracy",
    # Użycie wszystkich rdzeni procesora.
    n_jobs=-1)

# Obliczenie średniej i odchylenia standardowego dla wyników zbioru uczącego.
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)

# Obliczenie średniej i odchylenia standardowego dla wyników zbioru testowego.
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)

# Wyświetlenie średniej wyników dokładności dla zbiorów uczącego i testowego.
plt.plot(param_range, train_mean, label="Wynik uczenia", color="black")
plt.plot(param_range, test_mean, label="Wynik sprawdzianu krzyżowego", color="dimgrey")

# Wygenerowanie wykresu dokładności dla zbiorów uczącego i testowego.
plt.fill_between(param_range, train_mean - train_std,
                 train_mean + train_std, color="gray")
plt.fill_between(param_range, test_mean - test_std,
                 test_mean + test_std, color="gainsboro")

# Wyświetlenie wykresu.
plt.title("Krzywa weryfikacji dla algorytmu losowego lasu")
plt.xlabel("Liczba drzew")
plt.ylabel("Dokładność")
plt.tight_layout()
plt.legend(loc="best")
plt.show()
