22. Notes

Todo

  • Luźne notatki
  • tensorFlow
  • pyTorch
  • Julia (język programowania)
  • funkcyjne: higher order function -> przekazywanie funkcji jako argument
  • nltk - natural language toolkit
  • dodać algorytmy genetyczne
  • sklearn ma wiele datasetów, a te które mają prefix fetch_ zaciągają dane z internetu bo są większe

Todo

  • selekcja ficzerów
  • LDA, QDA, KNN. KNN akurat jest, i go wykorzystam
  • ROC, AUC
  • niezbalansowane klasy
  • Bagging, VotingClassifier
  • XGBoost
  • braki w danych

22.1. Data Science

  • Scientific Computing (stara nazwa Data Science)
  • analiza danych
  • łączenie danych z różnych źródeł

Machine Learning - uczymy konkretne modele przewidywać Budowa danych do uczenia modelu to jest zupełnie inna sprawa.

Eksploracja danych - poszukiwania trendów:

  • metody statystyczne
  • proste statystyki opisowe (kwantyle)
  • grupowania i opisowe statystyki
  • czy masz wartości wystające (nietypowe - outlayers)
  • odchylenia standardowe (czy obserwacje są 3 razy odchylenie)
  • czy to jest rozkład
  • można liczyć kurtozę
  • można liczyć średnie itp
  • rozklad Studenta-t stosujesz do 30 próbek, a w Machine Learning zwykle masz dużo więcej
  • czy rozkład jest gausem (czy jest wielomodalnym - złożeniem dwóch lub więcej rozkładów), np. wiek - gaus dla mężczyzn i dla kobiet, będzie inny
  • gaussian mixture models (model szuka ile modeli gaussowskich jest w dancyh)

Badacz Daych

22.1.1. Trzy dziedziny Data Science

  • Data Science (wymaga trochę programowania, ale mniej niż Engineering)
  • Data Engineering (przerzucanie danych z lewa na prawo - więcej programowania)
  • Statystyk (budowanie rozbudowanych modelów danych)

Różne źródła danych:

  • rozmawianie po api
  • różne formaty
  • pochodzenie

22.2. Jupyter

  • średnik usuwa wyświetlanie linii
  • zamykanie kerneli
  • instalowanie pluginów - spellchecker
  • list.pop? - znak apytania wyświetla help do obiektu
  • %%timeit
  • % - globalne
  • %% - dla komorki
  • ! uruchamianie terminala pod spodem (interoperacyjne z pythonem)

22.3. Machine Learning

bez nadzoru:

  • Poszukiwanie wzorców
  • najczęściej to jakiś rodzaj klastrowania
  • zmniejsza wymiarowość dancyh
  • wykrywanie anomalii
  • klastrownaie hierarchiczne

z nadzorem:

  • Przewidujemy trend w danych, które otrzymujemy

Musimy mieć więcej niż 50 próbek. Poniżej tej ilości można bawić się w statystykę ale nie w machine learning:

  • czy idziemy w stronę regresji czy klasyfikacji
  • czy mamy oznaczone dane czy nie (idzemy w unsupervised learning)
  • czy mamy więcej czy mniej niż 100k próbek

Pierwszy wybór jeżeli chodzi o klasyfikator to Regresja Logistyczna.

// obrazek ze slajdów z wyborem algorytmu

Są metody kóre mają problemy gdy mają zbyt dużo proóbek. Sieci neuronowe lubią mieć więcej próbek (dobrze z nimi działaj)

W problemach tekstowych dane są rzadkie. w problemach numerycznych możemy mieć więcej danych.

SGD - Stocastic Gradient Descent

Not working:

  • niestabilny algorytm (może nie zbiegać)
  • nie daje jakości klasyfikacji

22.3.1. Klastry

Definiujemy K klastrów i dzielimy przez odległość od środka klastrów PCA - znajdywanie wektorów własnych kowariancji (z wielowymiarowych przestrzeni możemy zbudować mniejwymiarowe) Dużo algorytmów stosuje odwracanie macieży, a komputery mają z tym problem, dlatego warto zmniejszyć jego poziom

PCA - Twój model będzie działał lepiej, ale nie wiesz który parametr ma większy wpływ na jakość, np:

  • długość, szerokość i położenie działki zamienia w jeden wektor
  • porównuje dane według tego wektoru
  • ale nie wiadomo które z długość, szerokość i położenie działki ma największy wpływ

22.3.2. Sieci Neuronowe

GAN - General Adversarial Network - używa się do obrazów, dźwięków - sieć jest dobrze nauczona, gdy nie potrafi rozróżnić danych wygenerowanych od prawidłowych. Analizując tekst, wylicza prawdopodobieństwo wystąpienia kolejnych słów po sobie

Deep Learning ma niski próg wejścia, trzeba tylko uważać na czystość danych. Karmimy model, a ktoś mądrzejszy wcześniej przygotował cały mechanizm. W klasycznym uczeniu maszynowym musimy sami tworzyć model.

Jak sieć neuronowa podejmuje na samym końcu decyzję (tzw. softmax) to stosuje regresję logistyczną.

22.3.3. Machine Learning

Klasyfikacja jest dyskretna (mamy skończoną listę klas) Regresja jest liniowa (mamy nieskończoną listę klas)

22.3.4. Regresja liniowa

  • Odczytywanie wartości z wykresu dla linii wykreślonej na podstawie danych.
  • Minimalna funkcja, która daje nam poprawną predykcję.
  • Mało podatna na overfitting
  • Podatna na underfitting
  • Dobra wartość dobroci w stosunku do trudności.
  • Bardzo często wykorzystywana.
  • Szczególnie często wykorzystywane w systemach RTB (Realtime Bidding) czyli system aukcji dla reklam na stronach, który musi wyrobić sięw 100-200ms (trzeba uwzględnić narzut sieciowy). Dla takich przypadków stosuje się regresję liniową albo logistyczną, bo decysja musi być podjęta bardzo szybko (wykorzystanie sieci neuronowych byłoby zbyt czasochłonne).
  • Przykładowy dataset: Diabetes (http://www4.stat.ncsu.edu/~boos/var.select/diabetes.html)
  • Sklearn wykorzystuje tablice numpy
  • Target - zmienna opisywana (y)
diabetes_X = diabetes.data[:, np.newaxis, 2]  # wyciągamy jako wektor kolumnowy (nie trzeba tego robić jak mamy więcej niż jedną kolumnę)
  • do cech (x) sklearn oczekuje wektora kolumnowego
  • ilość wierszy w wektorze (y) musi być taka sama
  • Zmienna opisująca
  • Zmienna opisywana
  • Im R2 jest bliżej 1 tym lepiej
  • wykres dla danych trenowanych
plt.scatter(diabetes_X_train, diabetes_y_train,  color='red')
plt.plot(diabetes_X_test, diabetes_y_pred, color='blue', linewidth=3)
plt.show()
plt.scatter(diabetes_X_test, diabetes_y_test,  color='black')
plt.plot(diabetes_X_test, diabetes_y_pred, color='blue', linewidth=3)
plt.show()
  • Zmienne lepiej opisujące (BMI) - mocny współczynnik mówiący o modelu
  • Zmienne gorzej opisujące (sex) kiepsko determinuje czy ktoś ma cukrzycę
  • W zależności od zmiennej regresja działa lepiej albo gorzej
  • Funkcja kosztu to nie tylko błąd średniokwadratowy ale również współczynnik wag.

22.3.4.1. Zadanie

  1. Użyj więcej zmiennych do uczenia modelu; porównaj wyniki pomiaru jakości regresji.
  2. Narysuj linię regresji w stosunku do innych zmiennych.
  3. ★ Jakie cechy wpływają na najbardziej na wynik? Jak to sprawdzić?
# np.newaxis - wyciągamy jako wektor kolumnowy (nie trzeba tego robić jak mamy więcej niż jedną kolumnę)
diabetes_X = diabetes.data[:, np.newaxis, 2]

# Dzielimy dane na zbiory treningowy i testowy
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]

diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]

# Tworzymy obiekt modelu i go uczymy
regr = linear_model.LinearRegression()

regr.fit(diabetes_X_train, diabetes_y_train)
diabetes_y_pred = regr.predict(diabetes_X_test)


print('Współczynniki: \n', regr.coef_)
print("Błąd średniokwadratowy: %.2f"
      % mean_squared_error(diabetes_y_test, diabetes_y_pred))
print('Metryka R2 (wariancji): %.2f' % r2_score(diabetes_y_test, diabetes_y_pred))


plt.scatter(diabetes_X_test, diabetes_y_test,  color='black')
plt.scatter(diabetes_X_train, diabetes_y_train,  color='red')
plt.plot(diabetes_X_test, diabetes_y_pred, color='blue', linewidth=3)
plt.show()
# 1, 2, 3 to są kolejne kolumny w których mamy cechy opisujące
diabetes_X = diabetes.data[:, [1, 2, 3]]

# Dzielimy dane na zbiory treningowy i testowy
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]

diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]

# Tworzymy obiekt modelu i go uczymy
regr = linear_model.LinearRegression()

regr.fit(diabetes_X_train, diabetes_y_train)
diabetes_y_pred = regr.predict(diabetes_X_test)


print('Współczynniki: \n', regr.coef_)
print("Błąd średniokwadratowy: %.2f"
      % mean_squared_error(diabetes_y_test, diabetes_y_pred))
print('Metryka R2 (wariancji): %.2f' % r2_score(diabetes_y_test, diabetes_y_pred))


# [:,2] wycinamy drugą kolumnę aby narysować wykres (bo matplotlib generuje wykresy dwuwymiarowe)
# to spowoduje pozostawienie jedynie x i y i odrzucenie pozostałych kolumn
plt.scatter(diabetes_X_test[:,2], diabetes_y_test,  color='black')
plt.scatter(diabetes_X_train[:,2], diabetes_y_train,  color='red')
plt.plot(diabetes_X_test[:,2], diabetes_y_pred, color='blue', linewidth=3)
plt.show()
# Wykres będzie chaotyczny,

22.3.4.2. Ciąg dalszy

  • Regresję logistyczną można wykorzystać dla tzw. okien danych. Gdy wykres rośnie a później maleje, to regresja liniowa byłaby linią prostą, a tak gdzy podzieli się wykres na połowę (rosnącą i malejącą) i stworzy się regresję dla przedziału.
  • Można to łatwiej zrobić tworząc pandas dataframe i przekazując je do sklearn
  • Przypadek dla wielu zmiennych opisujących:
import pandas as pd

dia_df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)\
    .assign(target=diabetes.target)

# Podiał zbioru na testowy i treningowy
dia_train = dia_df.iloc[:-20, :]
dia_test = dia_df.iloc[-20:, :]

lr = linear_model.LinearRegression()
lr.fit(dia_train[['age', 'sex', 'bmi']], dia_train['target'])

dia_test = dia_test.assign(predict=lambda x: lr.predict(x[['age', 'sex', 'bmi']]))

print('Współczynniki: \n', lr.coef_)
print("Błąd średniokwadratowy: %.2f"
      % mean_squared_error(dia_test['target'], lr.predict(dia_test[['age', 'sex', 'bmi']])))
print('Metryka R2 (wariancji): %.2f' % r2_score(dia_test['target'], dia_test['predict']))
  • Przypadek dla jednej zmiennej opisującej:
import pandas as pd

dia_df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)\
    .assign(target=diabetes.target)

# Podiał zbioru na testowy i treningowy
dia_train = dia_df.iloc[:-20, :]
dia_test = dia_df.iloc[-20:, :]

lr = linear_model.LinearRegression()
lr.fit(dia_train[['bmi']], dia_train['target'])

dia_test = dia_test.assign(predict=lambda x: lr.predict(x[['bmi']]))

print('Współczynniki: \n', lr.coef_)
print("Błąd średniokwadratowy: %.2f"
      % mean_squared_error(dia_test['target'], lr.predict(dia_test[['bmi']])))
print('Metryka R2 (wariancji): %.2f' % r2_score(dia_test['target'], dia_test['predict']))

22.3.5. Modele Chernove

  • Czy klient przedłuży umowę mając jakieś dane (analityk Ci mówi, bo dzwonił do 1000 osób i wie, że najczęściej zmieniają umowę gdy…):

    • czy przedłużał wcześniej
    • od kiedy jest
    • czy zgłaszał jakieś problemy z umową
    • jaka jest wartość abonamentu
    • ile dzwoni
    • możesz mierzyć dobroć oferty 0-100 czy np. nowa oferta jest dla klieta
  • Jak sprawdzić czy klient jest zadowolony? (np. śledzić trendy na FB, czy napisał, że jest niezadowolony):

    • Named Entity Recognition
    • Analiza Sentymentu (jak nacechowana jest wiadomość na social media)
    • Inżynieria cech z innych źródeł (typowy Data Science)
  • Mogą wystąpić dyskretne eventy, które wpływają na ofertę. Np jakieś wydarzenia na świecie itp które wpływają na model. np. premier błał łapówki a to jest firma publiczna, jej akcje spadną, więc trzeba uwzględnić w modelu możliwość wprowadzenia dyskretnych eventów wraz z wagą wydarzenia i wpływem na model. Tu wchodzi teoria gier i Nash

  • Ciężko jest przewidzieć wiek, ale łatwiej jest przewidzieć kubełki wieku (16-20, 20-25 itp). Zamieniasz problem ciągły na dyskretny. Przechodzisz z regresji na problem klasyfikacji. Nikogo nie obchodzi, że masz 26.5 roku, raczej, że jesteś w przedziale wiekowym 25-30 lat bo tak reklama jest targetowana.

  • Błąd średniokwadratowy (jak daleko punkty są od linii - tylko liczymy kwadraty tych odległości).

  • OLS - Ordinary Least Squares - można używać do czegokolwiek, trzeba mieć funkcję tylko trzeba napisać funkcję kosztu.

  • W zależności od danych, linia może być nie tak nachylona. np. jeżeli mamy trochę ekstremalnych wyników - które nie są ważne, to jest overfitting.

22.3.6. Regularyzacja

  • Regularyzacja - minimalizując funkcję kosztu, minimalizujesz wagi

  • Lasso L1 - sprowadza wartości nieistotne do zera (sprawdzić czy to nie definicja Ridge)

  • Ridge (dodaje regularyzację L2 wag) - sprowadza wartości nieistotne blisko do zera (sprawdzić czy to nie definicja Lasso)

  • Regularyzację można stosować do każdego modelu, nie tylko dla Regresji Liniowej.

  • Regularyzacja Ridge lub Lasso:

    • parametr alfa to waga regularyzacji, jak bardzo wagi wpływają na funkcję kosztu
    • jak dochodzą nam parametry do modelu to trzeba zmieniać parametr alfa
    • regularyzacja L1 często wywala parametry nieistotne do zera
    • Czasami parametr alfa=1.0 to wyniki mogą być gorsze.
    • Samo użycie regularyzacji w regresji liniowej sprowadza się do użycia modelu o innej nazwie
    • Czasami dobierając parametr alfa np. 0.5 to może polepszyć wynik

Jest wersja modeli które mają CV w nazwie (Cross Walidation):

  • LassoCV()
  • oprócz podziału na treningowy i testowy to dzielimy jeszcze na x małych części
  • trenujemy każdy przedział osobno i sprawdzamy jak błędy się rozkładają
  • domyślnie jest cv=3, cv=5 daje dobre wyniki
  • trzeba pamietać, aby zbiór mógł się na tyle podzielić, aby nie było tam zerowych wartości
  • sam z siebie zmienia parametr alfa i próbuje znaleźć wartość dla której model będzie najlepszy na podstawie wyliczania Mean Square Errors
  • lasso.alpha_ można zobaczyć jaki parametr jest najlepszy
  • Elastic Net - ważona regularyzacja L1 i L2, i sprawdzanie która lepiej działa.
  • Cechy binarne w modelach liniowych dziąłają tak sobie, modele drzewiaste dobrze sobie z nią radzą.
# %matplotlib inline

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from sklearn import datasets
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
from sklearn.linear_model import LassoCV


COLUMNS = ['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']


# Przygotowujemy zbiór danych
diabetes = datasets.load_diabetes()
dataframe = pd.DataFrame(diabetes.data, columns=diabetes.feature_names).assign(target=diabetes.target)

# Dzielimy na zbiór danych treningowych i testowych
dane_treningowe = dataframe.iloc[:-20, :]
dane_testowe = dataframe.iloc[-20:, :]

# Wybór modelu
model = LassoCV(cv=5)

# Nauka modelu
model.fit(dane_treningowe[COLUMNS], dane_treningowe['target'])
dane_testowe = dane_testowe.assign(predict=lambda df: model.predict(df[COLUMNS]))


# Do wyświetlania
wspolczynniki = model.coef_
blad_sredniokwadratowy = mean_squared_error(dane_testowe['target'], model.predict(dane_testowe[COLUMNS]))
metryka_r2_wariancji = r2_score(dane_testowe['target'], dane_testowe['predict'])

print(f'Współczynniki: \n{wspolczynniki}')
print(f'Błąd średniokwadratowy: {blad_sredniokwadratowy:.2f}')
print(f'Metryka R2 (wariancji): {metryka_r2_wariancji:.2f}')


# Wyświetlanie wykresu
plt.plot(-pd.np.log10(model.alphas_), model.mse_path_, linestyle='--');
plt.plot(-pd.np.log10(model.alphas_), model.mse_path_.mean(axis=1), 'k', linewidth=3);

plt.xlabel('$-log_{10}(alpha)$');
plt.ylabel('Mean Square Error (MSE)');

22.3.7. SVM

  • Kiedyś bardziej rozpowszechnione obecnie trochę mniej
  • Krenel Tricks (trik jądrowy)
  • Jeżeli dane nie są liniowo separowalne (tzn można przeprowadzić linię, która rozdzieli zbiór na dwie części)
  • Mapuje coś na jakąś funkcję np. koła i tak rozdziela punkty sprowadzając odległości od okręgu na płaszczyznę liniową (odległość punktu od okręgu)
  • Funkci się raczej nie pisze, używamy już istniejące.
  • Sara się znaleźć taką linię, która nie tylko najepiej aproxymuje punkty, ale także stara się by punkty graniczne były równoodległe od linii.
  • Funkcja Sinus jest przedziałami liniowa. Model polimianowy jest lepiej dopasowany.
  • Lepiej jest zastosować OLS i dopasować sinusoidę (np. do sygnałów z szumem warto dopasować sinusoidę)
  • Zwykle jednak nie znamy jaka to funkcja i trzeba szukać.
  • Modele wielomianowe są dużo bardziej złożone obliczeniowo.
  • SVM jest przydatny kiedy mamy ładne nieliniowe granice.
# %matplotlib inline

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from sklearn import datasets
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
from sklearn.svm import SVR


COLUMNS = ['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']


# Przygotowujemy zbiór danych
diabetes = datasets.load_diabetes()
dataframe = pd.DataFrame(diabetes.data, columns=diabetes.feature_names).assign(target=diabetes.target)

# Dzielimy na zbiór danych treningowych i testowych
dane_treningowe = dataframe.iloc[:-20, :]
dane_testowe = dataframe.iloc[-20:, :]

# Wybór modelu
model = SVR(kernel='linear', C=1e3)

# Nauka modelu
model.fit(dane_treningowe[COLUMNS], dane_treningowe['target'])
dane_testowe = dane_testowe.assign(predict=lambda df: model.predict(df[COLUMNS]))


# Do wyświetlania
wspolczynniki = model.coef_
blad_sredniokwadratowy = mean_squared_error(dane_testowe['target'], model.predict(dane_testowe[COLUMNS]))
metryka_r2_wariancji = r2_score(dane_testowe['target'], dane_testowe['predict'])

print(f'Współczynniki: \n{wspolczynniki}')
print(f'Błąd średniokwadratowy: {blad_sredniokwadratowy:.2f}')
print(f'Metryka R2 (wariancji): {metryka_r2_wariancji:.2f}')

22.3.8. Classification

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn import linear_model, neighbors, svm, tree, datasets
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.metrics import roc_curve, roc_auc_score, classification_report
%matplotlib inline

plt.rcParams['figure.figsize'] = (10, 8)

iris_ds = datasets.load_iris()

iris = pd.DataFrame(iris_ds.data, columns=iris_ds.feature_names).assign(target=iris_ds.target)
iris.columns = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'target']

iris_train, iris_test = train_test_split(iris, test_size=0.2)

Normalizacja nazw kolumn:

name = iris_ds.feature_names[0]
name.replace(' (cm)', '').replace(' ', '')

cols = [name.replace(' (cm)', '').replace(' ', '') for name in iris_ds.feature_names]

Wyświetlanie nazw targetów:

>>> iris_ds.target_names
array(['setosa', 'versicolor', 'virginica'], dtype='<U10')

# to jest później wykorzystywane do podmiany jako
# 0 - setosa
# 1 - versicolor
# 2 - virginica

Uwaga na train_test_split(iris, test_size=0.2) kiepsko działa, jeżeli jedna cecha jest słabo reprezentowana. Np ilość osób które mają raka. Zdecydowana większość nie ma raka.

  • Optymalizować nie tylko na Recall ale również F1
  • Dzielisz próbki by ilość była równoreprezentowana (ale trzeba losować w zależności od wielu zmiennych opisujących)
  • Szczególnie w tematach medycznych (neurologicznych) jest to często występujące: wtedy optymalizować Recall a nie precyzję.
  • Trzeba losować próbki tak, by rozkład był jak najbardziej podobny do rozkładu zbioru oryginalnego
  • Sprawdzasz jak bardzo zbiór oryginalny jest skrzywiony, a później coś robisz. zawsze popełniasz błąd, ale kwestia jak wielki
  • Decydujesz się którą rzecz optymalizujesz, false positive czy false negative
  • Recall = minimalizacja false negativów (lepiej zrobić fałszywy alarm, niż nie wykryć)

22.3.9. Łańcuchy markova

  • konwersja z reklam
  • totalnie nie interesuje Cię co nie konwertuje
  • patrzysz na to na czym ludzie odpadają (np. układ strony, pozycja itp)

22.3.10. Regresja logistyczna

22.3.11. Recall

  • Liczymy to ilościowo, tzn. czy zgadł czy nie

  • Precision - ile zgadł poprawnie z wszystkich

  • Recall - ile false positiwów wystąpiło

  • F1 - średnia precyzji i recall

  • F1 = 2 * (precision * recall) / (precision + recall)

    • tp = true positives
    • fn = false negatives
  • Recall = tp / tp + fn

  • Type 1 i Type 2 error (częste pytanie na rozmowach kwalifikacyjnych):

    • Type 1 czyli tzw. false positive - powiedzieć mężczyżnie że jest w ciąży
    • Type 2 czyli tzw. false negative - ciężarnej kobiecie powiedzieć, że nie jest w ciąży
  • False negativy staramy się eliminować, szczególnie w sytemach medycznych

  • Support = ile mamy elementów w naszym zbiorze testowym

features = ['sepal_length', 'sepal_width']  # ['petal_width', 'petal_length'] daje lepsze wyniki
logreg = linear_model.LogisticRegression(C=1e5)
logreg.fit(iris_train[features], iris_train['target'])
print(classification_report(iris_test['target'], logreg.predict(iris_test[features])))
  • Jak użyjemy płatków, to nasz problem jest dużo lepiej liniowo separowalny.
  • Jeżeli użyjemy kielichów, to cenchy bardziej się se sobą mieszają.
  • Dla problemów muiltiklasowych, można zamienić model na:
logreg = linear_model.LogisticRegression(C=1e5, multi_class='multinomial', solver='sag')
  • Konwergencja = zbieżność
  • Przy minimalizacji Epsilon określa zbieżność
  • Jeżeli docierając do maksymalnej iteracji gradient będzie zbyt stromy, to wywali error konwergencji
  • Wtedy trzeba zwiększyć ilość iteracji
logreg = linear_model.LogisticRegression(C=1e5, multi_class='multinomial', solver='sag', max_iter=1e6)
  • Model sag dobrze działa dla dużych dancyh, i wtedy dobrze zbiega i nie trzeba zwiększać max_iter
logreg = linear_model.LogisticRegression(C=1e5, multi_class='multinomial', solver='lbfgs')
  • Jest szybszy, ale nie jest lepszy w optymalizacji globalnej. może błędnie wykryć minimum lokalne funkcji i błędnie pomyśleć, że jest to minimum globalne wielomianu.
  • Zamiana petal z sepal w tym przypadku jest dużo ważniejsze niż zmiana solvera.
  • SVC - modele support vector classifier
  • SVR - support vector regression
  • OVR - One vs Rest
  • Przestrzeń decyzyjna = pole na wykresie
svc = svm.LinearSVC(multi_class='ovr')
svc = svm.LinearSVC(multi_class='crammer_singer')

# C - parametr nieliniowości
# Podniesienie C daje model bardziej nieliniowy
svc = svm.SVC(kernel='rbf', C=1e3)

svc = svm.SVC(kernel='rbf', C=1)
  • Mapuje funkcję nieliniową na płaszczyznę.
  • Ten problem jest rozsądnie liniowo separowalny i nie warto używać bardziej skąplikowanych modelów, bo może skutkować to przeuczaniem.
  • Teraz są popularne modele XGBoost (model drzewiasty)
  • Modele drzewiaste dobrze sobie radzą z cechami dyskretnymi.
  • Cecha dla zgadnięcia tego wyniku jest bardzo silna.

22.3.12. Ensamble

  • Ensamble to jest połączenie wielu modeli.
  • Najczęściej się to stosuje w połączeniu Modeli drzewiastych.

22.3.13. K-Nearest Neighbors

  • To bardziej algorytm niż model. Programiści go lubią bo jest mniej matematyki.
  • Jest bardzo prosty.
  • Uczy się danych na pamięć.
  • Jest parametr, weights='uniform' (niezależnie od tego jak są daleko)
  • Ale możemy też ważyć ilu jest bliskich sąsiadów a ilu dalekich (weights='distance').
  • Można także użyć [callable] tj. przekazać funkcję, która liczy wagi
def my_function(*args):
    print(args)

knn = neighbors.KNeighborsClassifier(n_neighbors=3, weights=my_function)

Zalety:

  • Super prosta
  • Dane reprezentują co dostaniemy (nie ma koncepcji funkcji)
  • Jeżeli problem jest super nieliniowy, to będzie działało dobrze
  • zapamiętuje dane, więc jak problem będzie duży to zapamięta dużo danych
  • łatwo douczać
  • jest bardzo szybki

Model najczęściej wykorzystuje się w analizie danych strumieniowych:

  • uczymy model, analizujemy
  • dostajemy nowe dane, uczymy model i znów analizujemy
  • model adaptacyjny

Modele strumieniowe:

  • uczone raz, tzw. offline’owe
  • douczane w trakcie, tzw. online (adaptują się do naszych danych) - ciężej nad nimi panować. Jeżeli się doucza sam, to ciężko panować nad jakością tego, więc trzeba monitorować.

Note

KNeighborsClassifier() i n_neighbors - pisownia amerykańska, bo angielska ma u w środku

Duży model SVM może być wolniejszy

Dobór parametru n_neighbors zwykle jest na czuja:

  • im więcej punktów tym więcej można sąsiadów dobrać
  • standardowo zaczayna się od 5 lub 3 ale częściej 5
  • różnica pomiędzy 5 a 10 mówi o gęstości punków
  • zbyt duże wartości parametrów niekoniecznie wpływa na jakość

Model bardzo szybko się uczy i klasyfikuje, więc można zmieniać parametry w trakcie i monitorować.

22.3.14. Drzewa decyzyjne

  • Najszczęściej w postaci drzewa binarnego - z dwoma opcjami:

    • znajdują nam formę klastrów związane z danymi
    • odzworowują procesy biznesowe
  • Entropia - uporządkowanie lub chaotyczność układu

  • Gini Index - używa się jako index ekonomiczny w konktekście nierówności społecznych

  • Criterion # Indeks informacyjności # The function to measure the quality of a split:

    • criterion=’gini’ # Gini impurity (nierówności)
    • critetion=’entropy’ # for the information gain
  • Albo chcesz dużą informacyjność albo dużą nierówność.

  • Przestrzenie decyzyjne są w formie prostokątów ze względu na binarność decyzji:

    • inaczej rosną przyrosty wartości
    • może to powodować zmniejszanie dokładności

Zalety:

  • dobrze działają z wartościami kategorycznymi (lewo-prawo, mężczyzna-kobieta)
  • w miarę szybkie (tak naprawdę to wiele zagnieżdżonych ifów)
  • generują algorytm biznesowy pod spodem dla naszej logiki (bardzo często drzewa stosuje się tylko po to, aby odkryć klasę problemów)

Wady:

  • rzadziej używane jako klasyfikatory
  • przestrzenie klasyfikacyjne są prostokątne co kiepsko oddaje charakter liniowych danych
  • mają tendencję do przeuczania się (ma problemy z generalizacją)
  • zbyt dużo parametrów, którymi można sterować, co powoduje, że musimy sprawdzić bardzo dużo przypadków
  • best jest greedy algorytm, ale czasami ten podział późniejszy jest istotniejszy niż ten który dopasował na początku.

Zawsze bierze ten który ma najwięszą wartość na wyższym stopniu.

22.3.15. CART - Classification and Regression Trees

W drzewach jest dużo parametrów:

  • ograniczanie rozbudowy drzewa
  • podejmowanie losowych decyzji
  • feature_importance
  • drzewa można nauczyć największej ilości featerów

22.3.16. Kalibracja parametrów modeli

Greed search CV:

  • przeszukiwanie przestrzeni hiperparametrów
  • cross validation
param_grid = [
  {'C': range(1, 1000, 10), 'kernel': ['linear']},
  {'C': [1, 10, 100, 1000, 1e4, 1e5], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']},
]

# Przejrzyj całą przestrzeń parametrów aby dobrać najlepszy model
svc = GridSearchCV(svm.SVC(probability=True), param_grid, return_train_score=True)

features = ['sepal_length', 'sepal_width']
svc.fit(iris_train[features], iris_train['target'])
print(classification_report(iris_test['target'], svc.predict(iris_test[features])))
>>> svc.best_estimator_
SVC(C=100, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma=0.001, kernel='rbf',
  max_iter=-1, probability=True, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

>>> svc.best_params_
{'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}

>>> svc.cv_results_
# można przejrzeć wartości

Splity - podziały crosswalidacyjne

22.3.17. Ocena jakości modelu

Aby ocenić jak dobrze model klasyfikuje, czy przeprowadza regresję, używamy wielu metryk, które mają za zadanie skupić się na poszczególnych parametrach modelu.

Dla regresji:

y_true = iris_test['iris_class']
y_pred = svc.predict(iris_test[features])

print(classification_report(y_true, y_pred))

Dla Klasyfikacji:

from sklearn.metrics import precision_score, recall_score, f1_score

avg = 'macro'
print('Precision: {:.4f}'.format(precision_score(y_true, y_pred, average=avg)))
print('Recall: {:.4f}'.format(recall_score(y_true, y_pred, average=avg)))
print('F1: {:.4f}'.format(f1_score(y_true, y_pred, average=avg)))

Lub dla każdej klasy jak w raporcie:

from sklearn.metrics import precision_recall_fscore_support

precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred)
precision, recall, f1, support
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_true, y_pred)

Confusion matrix:

  • pokazuje jak zgadywaliśmy
  • najlepiej jeżeli na diagonalach jest 0 (to znaczy, że nie popełniliśmy błędów)

Jaccard similarity score:

  • ile mamy elementów w części wspólnej (unii) zbirów

ROC (receiver operating characteristic):

  • stosuje się dla problemów dwuklasowych
  • dla wieloklasowych jest problematyczne bo trzeba podzielić na OVR
  • pokazuje jak bardzo klasy są od siebie oddalone

(linia konwolucji - splotu) czyli nachodzenie na siebie rozkładów na wykresie miara AUC - Aread under the curve - im bliżej 1.0 tym lepiej

Zgadywnie jak bardzo dobrze potrafimy klasyfikować poszczególne klasy

Jeżeli mamy wiele klas to najczęściej je uśredniamy

Najczęściej: - confusion matrix - zmieniamy miarę, którą optymalizujemy i wtedy dostajemy trochę inny model

22.3.18. Dane tekstowe

  • Jak zareprezentować tekst, aby można było coś na jego temat powiedzieć?
  • Dane tekstowe zazwyczaj przychodzą w formie dokumentów
  • Najczęściej klasyfikujemy dokumenty i przypisujemy im klasy (spam - nie spam, pozytywny tekst - negatywny)

MTD - Macierz TD (Term-Document):

  • budowanie macieży z każdego słowa w zdaniu
  • bardzo dużo wierszy i kolumn
  • każde słowo to osobna kolumna, a wartość to ile razy w zdaniu
  • dużo rzadkich danych - słowa wspólne rzadko występują we wszystkich zdaniach
  • trzeba wszystkie dane sprowadzić do małych znaków (inaczej będziemy mieli dużo wersji)
  • odmiana wyrazów ma znaczenie (usuwanie liczb mnogich, fleksja - odmiana słów itp)
  • trzeba uwzględnić, że w dancyh mogą być literówki
  • stemer - odcinanie końcówek (databases utnie do database) - zależne od języka
  • lematyzator - hasłowanie
  • part of speach tagger - rozpoznawanie części mowy
  • używając stemerów i lemazytorów powoduje utratę informacji (np. zamieniając databases na database, gubimy info o liczbach mnogich)
  • wordnet - słowniki

W klasyfikacji spamu, wielkość liter ma znaczenie

CountVectorizer() HashVectorizer() - częściej wykorzystywany przy dużych danych,

Dają nam sparse matrix czyli lista krotek, gdzie w naszej macieży znajduje się nasz wyraz, jest dużo zer i dlatego nie warto zapamiętywać tych danych a jedynie miejsca gdzie występują unikalne wartości

Problemy tekstowe są generalnie rzadkie, więc często będzie wykorzystywało się sparse matrix

Nie będzie stop list (stop wordów), czyli wyrazów pojawiających się tak często, że nie ma sensu ich analizować (I, and, or, itp) - zależne od języka (trzeba przekazać własną listę stopwordów).`

Można ustawić CountVectorizer(analyzer=’word’) ale można również ustawić na podział na zdania.

Tokenizacja - podził na wyrazy

NLTK - standardowy do analizy mowy języka polskiego Dużo narzędzi do języka polskiego jest w Javie:

  • np morfeusz (analizator morfologiczny) daje nam nie tylko części mowy ale również morfen - umie rozmawiać z pythonem

Słowosieć PLWORDNET

Tokenizator Sentence splitter - (splitowanie po kropce, ale nie uwzględnianie skrótów, m.in., itp) Apple może znaczyć jabłko ale również i firmę bigram - czyli okolice wyrazu Apple computers wskazuje na firmę

22.3.19. Term Frequency–Inverse Document Frequency (TF-IDF)

ma w sobie countVectorizer() oraz TfidfTransformer():

  • liczy ile razy coś się pojawiło (dzieli przez ile wyrazów pojawiło się w danym dokumencie)
  • waży się jeszcze przez to ile razy to się pojawiło we wszystkich dokumentach
  • im częściej coś się pojawia we wszystkich dokumentach tym wyraz jest ważniejszy
  • im żadziej w danym dokumencie coś się pojawiło tym ważniejsze

Nas interesuje jak często wyraz pojawia się w książce, ale nie ile razy:

  • książka 200 stron może mieć większą ilość wystąpień (proporcjonalnie) do książki 1000 stron

Zbiór jest zbalansowany do uczenia (wagi są od 0.0-1.0)

22.3.19.1. Cosine Similarity

  • długie wektory wielowymiarowe
  • Czy dokumenty są podobne do siebie? - liczymy cosinus konta wektorów
  • Jeżli naszymi cechami są słowa, to jeżeli w dokuemntach są te same ilości słów - to dokumenty są takie same
  • uwaga, bo słowa mogą mieć różną kolejność
  • dostajemy macierz (nasze dokumenty) na diagonalach dostajemy podobieństwo dokumentów
  • każdy wiersz tabelki TF-IDF to wektor (ilość słów to liczba wymiarów), wartości to częstości występowania
  • często używana w modelach

22.3.19.2. Miara Levensteina

  • jak bardzo jedna sekwencja jest podobna do drugiej
  • nie obchodzi jej gdzie ta sekwencja występuje
  • wykorzystanie difflib.SequenceMatcher(None, tekst_a, tekst_b).ratio()
  • czy te literki występują na tych samych miejscach, kompletnie nie ma znaczenia znaczenie (cat i caterpillar)
  • ile trzeba wprowadzić modyfikacji, aby stringi wyglądały tak samo
  • często się stosuje do tekstów
  • jest miarą pozycyjną

22.3.19.3. Miara Jaccarda

  • można liczyć na wiele sposobów
  • ile mamy elementów na przecięciu setu

22.3.20. Transformatory i pipeline

  • Transformer - jak transformujemy dane
  • Pipeline - łączy transformatory
  • Estimator - model

22.3.20.1. Sposób na rozszerzanie sklearn

  • kolejność elementów w pipeline jest ważna
  • składa się ze steps
  • na każdym obiekcie wykona pipeline.fit_transform()
  • można nazywać kolejne elementy pipeline
  • można je podawać jako słownik (uwaga na zmieniającą się kolejność, lepiej użyć OrderedDict)
  • aby uciszyć error sklearn.preprocessing.FunctionTransformer() trzeba dać validate=False, ma to związek z tym, że oczekuje wartości float. Transformer jest w pełni gotowy do przetwarzania danych tekstowych

22.3.20.2. Pipeline

  • stosowane do oczyszczania dancyh, np. usuwania liczb mnogich, usuwania ul. os. pl. itp z nazw ulic
  • jezeli jest coś bardziej skomplikowanego, to lepiej użyć klasy dziedziczącej po BaseEstimator i FunctionTransformer

22.3.21. Klasyfikacja dancyh tekstowych

22.3.22. Naive Bayes

  • Naive dlatego, że uznaje wszystkie cechy za liniowo niezależne
  • dla dokumentów tekstowych jest to bardzo poprawne
  • prawdopodobieństwo jest nie tylko zależne od tego ile razy wystąpiło, ale również z naszą wiedzą ekspertcką
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
import pandas as pd

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/00228/smsspamcollection.zip'
# z pliku SMSSpamCollection odczytaj plik i wczytaj
sms = pd.read_csv(plik_danych, sep='\t', names=['is_spam', 'text'])
train_sms, test_sms = train_test_split(sms, test_size=0.2)

steps = [('tfidf', TfidfVectorizer()), ('cls', MultinomialNB())]
nb_pipe = Pipeline(steps=steps)
nb_pipe.fit(train_sms['text'], train_sms['is_spam'])

y_pred = nb_pipe.predict(test_sms['text'])
y_true = test_sms['is_spam']

print(confusion_matrix(y_true, y_pred))
print(classification_report(y_true, y_pred))

22.3.23. Modelowanie tematów

  • uczenie bez nadzoru
  • gensim i model LDA (Latent Dirichlet Allocation)
  • pakiet nie usuwa stopwordów

22.4. Metody bez nadzoru

  • Klastrowanie - Minus: musimy powiedzieć ile chcemy mieć klastrów
  • Algorytm K-Means bardzo często wykorzystywany (liczą gdzie jest środek geometryczny punktów, a później klasyfikuje
  • Batch k-means - nie bierze wszystkich danych na raz, tylko dane po kawałku
  • K-Means można użyć do danych dużych (batch) oraz dla danych strumieniowych (przychodzących)
  • K-Means z pamięcią i z zapominaniem
  • W k-means nie przywiązywać się do nazwy klastrów (mogą być przydzielane losowo) ale zawsze ilość klastrów będzie się zgadzała
  • MiniBatchKMeans()
  • K-Means nie bardzo sobie radzi z tym jak klastry są podzielone
  • Jeżeli odległość między dwoma centroidami jest niewielka to opisują ten sam klaster
  • K-Means jest prosty obliczeniowo
  • Dendrogramy - drzewa - przy klastrowaniu hierarchicznym możemy odcinać drzewa klastrów w hierarchii na interesującym nas poziomie zagnieżdżenia
  • Dendrogram - rysunej hierarhiczności klastrów w postaci drzewa
  • Jeżeli nie wiemy ile klastrów, to lepiej zacząć od budowania dendrogramów i zobaczenie jak dane są połączone
  • K-Means nie bierze geometrii - tylko odległość
  • Klastry Aglomeracyjne

Dryft - zmiana w danych (np. przy mierzeniu ilości ruchu (w ciągu dnia możemy mnieć mniej wrażliwy system, a w nocy bardziej wrażliwy na pojedyńcze alarmy)

  • Stabilizacja klastrów
  • Adaptowanie modelu

22.4.1. PCA

  • Analiza wektorów własnych macierzy kowariancji, które rozpinają system bazowy
  • gdy mamy dużo zmiennych które są skorelowane (np. Naive Bayes nie lubi tego)
  • często stosuje się do rysowania wielowymiarowych danych
  • Word to weg generuje 100-300 stopni swobody i można zastosować PCA aby sprowadzić do 2 lub 3 wymiarów
  • PCA jest transformatorem a nie modelem
# Jak dobrze wektor tłumaczy wariancję
pca.explained_variance_ratio_
  • System jest odwrócony względem wektorów
  • Składa ze sobą wartości skorelowane, np. jeżeli długość działki rośnie to prawdopodonie i szerokość również, PCA złączy je ze sobą

22.4.2. Sieci neuronowe

  • Detekcja sentymentów na podstawie wyrazu twarzy która patrzy na reklamę

  • SKLearn nie jest narzędziem deeplearningowym, ale ma w sobie zaimplementowane sieci neuronowe

  • Sieci neuronowe są dość trudne w porównaniu z innymi rodzajami

  • Przy analizie obrazu na wejściu są pixele w skali szarości.

  • matshow (część plt.subplot pokazuje macież jako obrazek

  • Sieć neuronowa uczy się backpropagation w każdym przejściu sieci

  • Większość sieci bazuje na obrazkach 300x300 px

  • Preprocessing:

    • usuwanie kolorów
    • zmniejszanie do wspólnych rozmiarów
  • TensorFlow

  • PyTorch

  • Caffe

22.4.2.1. Pojęcia

  • warstwa wejściowa
  • warstwy ukryte
  • warstwa wyjściowa
  • Przestrzeń wag
  • SGD - Stocastic Gradient Descent
  • Backpopagation
  • Epoki (kolejne przejścia dla propagacji)
  • Label detection - wykrywanie cech z obrazka