Regresja logistyczna jest algorytmem klasyfikacji uczenia maszynowego.

Model Regresji Regresja logistyczna jest algorytmem klasyfikacji uczenia maszynowego.
Model Regresji Logistycznej służy do przewidywania stanu zmiennej zależnej. Zmienna zależna jest w regresji logistycznej zmienną binarną, która przyjmuje postać: 1 i 0. W modelu tym zmienna zależna 1 oznacza zwykle potwierdzenie natomiast 0 oznacza zaprzeczenie.
służy do przewidywania stanu zmiennej zależnej. Zmienna zależna jest w regresji logistycznej zmienną binarną, która przyjmuje postać: 1 i 0. W modelu tym zmienna zależna 1 oznacza zwykle potwierdzenie natomiast 0 oznacza zaprzeczenie.

Założenia Modelu Regresji Logistycznej

1. Zmienna zależna musi mieć postać binarną
2. W modelu należy uwzględnić tylko zmienne niezależne mające istotny wpływ na zmienną zależną.
3. Zmienne niezależne muszą być od siebie niezależne (nieskorelowane).
4. Regresja logistyczna wymaga dość dużych rozmiarów próbek.

Otwórzmy plik danych wraz z niezbędnymi bibliotekami. Będziemy pracowali nad plikiem historii operacji na kartach płatniczych. Kolumnie ‘Class’ wartości 0 oznaczają brak malwersacji, 1 oznacza dokonanie malwersacji.

Przyjmijmy założenie, że celem podstawowym jest właściwe zaklasyfikowanie jak największej liczby malwersacji. Może odbywać się to kosztem wskazywania  sporej liczby zwykłych transakcji jako malwersacji.

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

from sklearn.preprocessing import StandardScaler, Normalizer, scale
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier
from sklearn.svm import SVC, LinearSVC
from sklearn.metrics import confusion_matrix, log_loss, auc, roc_curve, roc_auc_score, recall_score, precision_recall_curve
from sklearn.metrics import make_scorer, precision_score, fbeta_score, f1_score, classification_report
from sklearn.model_selection import cross_val_score, train_test_split, KFold, StratifiedShuffleSplit, GridSearchCV
from sklearn.linear_model import LogisticRegression

from sklearn import metrics
from sklearn.metrics import classification_report, confusion_matrix

df = pd.read_csv('c:/1/creditcard.csv')
df.head(3)

df.columns

Analiza zbilansowania zmiennych zależnych

Zbiór zmiennych zależnych jest zbilansowany wtedy, gdy stany 1 i 0 ma podobną liczbę wystąpień. Zazwyczaj zmienne wynikowe nie są zbilansowane, ponieważ zwykle bada się jakieś rzadkie zjawisko reprezentowane przez zmienną wynikową 1 na tle ogromnej liczby 0.

Gdy zbiór zmiennych wynikowych jest niezbilansowany, wtedy możemy mieć do czynienia ze zjawiskiem, kiedy model będzie ignorował wystąpienia 1 a i tak zachowa bardzo wysoki wskaźnik kompletności wyników (recall).

Przy drastycznej asymetrii występowania 0 i 1, nawet jeżeli model regresji logistycznej zignoruje wszystkie wystąpienia 1 i tak zachowa recall na bardzo wysokim poziomie.

 

Sprawdzenie poziomu zbilansowania wartości wynikowych

df.Class.value_counts(dropna = False)

sns.countplot(x='Class',data=df, palette='GnBu_d')
plt.show()

Wykres nie jest zbyt czytelny, warto więc sprawdzić strukturę procentową zmiennych wynikowych.

df.Class.value_counts(dropna = False, normalize=True)

Widzimy, że skala malwersacji reprezentowana przez 1 w kolumnie ‘Class’ stanowi niespełna 0,46

Zbiór jest więc głęboko niezbilansowany.

Analiza zmiennych niezależnych Modelu Regresji Logistycznej

Według wymienionych wcześniej założeń do Modelu Regresji Logistycznej

• W modelu należy uwzględnić tylko zmienne niezależne mające istotny wpływ na zmienną zależną.
• Zmienne niezależne muszą być od siebie niezależne (nieskorelowane).

 

W pierwszej kolejności zbadamy jaki wpływ na zmienna zależną mają poszczególne zmienne niezależne.

CORREL = df.corr().sort_values('Class')
CORREL['Class']

Wektor korelacji pomiędzy zmienną zależną a poszczególnymi zmiennymi niezależnymi wykazał, że niektóre zmienne mają bardzo niskie, graniczące z zerem poziomy korelacji.

Analiza statystyczna zmiennych niezależnych

Teraz wyświetlimy statystyki kilku zmiennych w próbie. Zmienne typu V mają bardzo podobne charakterystyki więc nie wyświetliłem tylko kilka z pośród nich.

Wyraźnie widać, że zmienne typu V znacznie różnią się od zmiennych niezależnych ‘Time’ i ‘Amount’.

Sprawdźmy jaki wpływ na zmienną zależną maja obie te zmienne.

df.groupby('Class').Amount.mean()

Widać, że istnieje istotna różnica w stanie średnich pomiędzy zmienną wynikową 1 i 0.

Dzieje się tak mimo wyraźnego braku korelacji między zmianną ‘Amount’ i zmienną zależną ‘Class’.

pd.pivot_table(df, index='Class', values = 'Amount', aggfunc= [np.mean, np.median, min, max, np.std])

pd.pivot_table(df, index='Class', values = 'Time', aggfunc= [np.mean, np.median, min, max, np.std])

Zmienna ‘Time’ wykazuje małe różnice pomiędzy 0 a 1, nie wykazuje też korelacji ze zmienną zależną, dlatego nie bierzemy jej pod uwagę w budowaniu modelu.

Zmienną ‘Amount’ należy użyć przy tworzeniu Modelu Regresji Logistycznej pomimo braku korelacji ze zmienną zależną.

Aby użyć zmienną niezależną ‘Amount’ należy ją najpierw zestandaryzować.

scaler = StandardScaler()
df['Amount'] = scaler.fit_transform(df['Amount'].values.reshape(-1, 1))

Analiza korelacji zmiennych

Korelacja zmiennych wynikowych nie jest dobrym zjawiskiem przy budowie Modelu Regresji Logistycznej.

sns.heatmap (df.corr (), cmap="coolwarm")

Brak jakiejkolwiek wysokiej korelacji pomiędzy zmiennymi niezależnymi. Na wykresie widać poszczególne wysokie korelacje zmiennych niezależnych ze zmienną zależną.

Wszystko jest OK.

Przed rozpoczęciem tworzenia modelu usuwamy wszystkie rekordy z pustymi komórkami.

Tworzenie Modelu Regresji Logistycznej

Wskazuje na zmienne egzogeniczne i na kolumnę wynikową zmienną endogeniczną.

feature_cols = ['V1', 'V2', 'V4', 'V5', 'V6', 'V8', 'V9', 'V10', 'V11', 'V12', 'V13', 'V14', 'V15', 'V16', 'V17', 'V18', 'V19', 'V20',
       'V21', 'V22', 'V23', 'V24', 'V25', 'V26', 'V27', 'V28', 'Amount']
X = df[feature_cols] 
y = df.Class

Wskazuje na podział na zbiór treningowy i zbiór testowy.

Xtrain, Xtest, ytrain, ytest = train_test_split(X, y, test_size = .33, stratify = y, random_state = 148)

Tworzymy ustawianie siatki Grid.

Parameteres = {'C': np.power(10.0, np.arange(-3, 3))}
LR = LogisticRegression(warm_start = True)
LR_Grid = GridSearchCV(LR, param_grid = Parameteres, scoring = 'roc_auc', n_jobs = 5, cv=2)

Wyjaśnienia do kodu:

 Parameteres = {'C': np.power(10.0, np.arange(-3, 3))} 

array([1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02])

Czyli typowe ustawienia dla siatki.

 warm_start  – algorytm wykorzystuje poprzednie wyniki modelu. Gdy warm_start =True, istniejące atrybuty dopasowanego modelu są używane do inicjalizacji nowego modelu w kolejnym wezwaniu do dopasowania w celu przyspieszyć konwergencji. warm_start jest przydatny przy wielokrotnym dopasowaniu tego samego estymatora z tymi samymi danymi, ale przy różnych parametrach.

 

 scoring = 'roc_auc' 

Wykres ROC ocenia najlepsze ustawienie klasyfikacji. Wyszukuje obszar pod „zakrzywioną” krzywą ROC, która jest prawdopodobnie najlepszym sposobem do pomiaru wydajności klasyfikacji w ramach wyszukiwania siatki.

 jobs = 5 

Liczba zadań do uruchomienia równoległego.

 cv = 2 

Oznacza ilość weryfikacji krzyżowych.

 

Model przyjmuje postać równania:

LR_Grid.fit(Xtrain, ytrain)

Sprawdzam, jaką konfigurację superparametru wygrał Grid.

print("The Best parameter:",LR_Grid.best_params_)
print("The Best estimator:",LR_Grid.best_estimator_)

Ewaluacja Modelu Regresji Logistycznej

Proszę wprowadzić do kodu blok diagnostyczny.

print("\n------Training data---------------------------------------------------")
print("The RECALL Training data:      ", np.round(recall_score(ytrain, LR_Grid.predict(Xtrain)), decimals=3))
print("The PRECISION Training data:   ", np.round(precision_score(ytrain, LR_Grid.predict(Xtrain)), decimals=3))
print()
print("------Test data-------------------------------------------------------")

print("The RECALL Test data is:        ", np.round(recall_score(ytest, LR_Grid.predict(Xtest)), decimals=3))
print("The PRECISION Test data is:     ", np.round(precision_score(ytest, LR_Grid.predict(Xtest)), decimals=3))
print()
print("The Confusion Matrix Test data :--------------------------------------")
print(confusion_matrix(ytest, LR_Grid.predict(Xtest)))
print("----------------------------------------------------------------------")
print(classification_report(ytest, LR_Grid.predict(Xtest)))

# PLOT
y_pred_proba = LR_Grid.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest,  y_pred_proba)
auc = metrics.roc_auc_score(ytest, y_pred_proba)
plt.plot(fpr, tpr, label='Logistic Regression (auc = 
#plt.axvline(0.5, color = '#00C851', linestyle = '--')
plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()

Model Regresji Logistycznej dobrze estymuje zdarzenia oznaczone jaki 0, gorzej ze zdarzeniami 1 (malwersacje). Poziom recall dla malwersacji wynosi zaledwie 65

Pamiętajmy, że model został stworzony głębokim niezbilansowaniu zbioru zmiennej zależnej.

Wykorzystaliśmy równie z wszystkie zmienne mimo że część z nich nie wykazywała korelacji ze zmienną zależną.

Aby wyświetlić same zmienne o wysokim poziomie (powyżej 0.2) korelacji ze zmienną zależną ‘Class’trzeba wpisać:

kot = CORREL[(CORREL['Class']>0.2)|(CORREL['Class']<-0.2)][['Class']]
kot.index

Teraz podstawimy wyłącznie te zmienne do modelu.

Wynik okazuje się rozczarowujące, model pogorszył swoje właściwości. Wracam więc od wcześniejszych ustawień modelu.

 

W kolejnych odcinkach będę starał się polepszyć model aby efektywnie wyłapywał wszystkie malwersacje

Kolejne kroki w tym procesie to :

1. Oversampling
2. Zmiany granic prawdopodobieństwa
3. Zabiegi na wagach.

Next part:

Model Regresji Logistycznej. Część 2: Oversampling

 

Zmiany progu w modelu regresji logistycznej i poprawa wskaźnika 'recall' kosztem zaśmiecenia wyników, czyli spadkiem poziomu dokładności 'precision'.

W poprzednich częściach omówiliśmy jak przygotowywać dane i jak tworzyć model regresji logistycznej. Mówiliśmy również o tym, w jaki sposób zmienić ilość danych, tak aby przy zmniejszyć wpływ niezbilansowania w zbiorze treningowym podczas tworzenia modelu regresji logistycznej.

Mówiliśmy również o tym, w jaki sposób należy zmienić ilość niezbilansowania w zbiorze treningowym podczas tworzenia modelu regresji logistycznej.

Wcześniejsze części można znaleźć pod tymi adresami:

Przykład Modelu Regresji Logistycznej. Część 1: model podstawowy

Model Regresji Logistycznej. Część 2: Oversampling

Tym razem zajmiemy się kolejną techniką pozwalającą na uzyskanie czułości modelu na zjawiska rzadkie. Przypomnijmy kontekst naszych ćwiczeń. Dla banku bardzo ważne jest to, jaki model zostanie szybko wykryty. Klient zgadza się na ponowny zakup dodatkowych danych ze wskazaniem przez model na anomalię, mimo, że zdarzenia te nie są malwersacjami.

 

Zmiana progu w modelu regresji logistycznej

W modelu regresji logistycznej domyślny próg prawdopodobieństwa wynosi 0,5

LR_Grid_ytest = LR_Grid.predict_proba(Xtest)[:, 1]
new_threshold = 0.1  
ytest_pred = (LR_Grid_ytest >= new_threshold).astype(int)

 

Uruchamiamy moduł diagnostyczny.

print("\n------Training data---------------------------------------------------")
print("RECALL Training data (new_threshold = 0.1):      ", np.round(recall_score(ytrain, LR_Grid.predict(Xtrain)), decimals=3))
print("PRECISION Training data (new_threshold = 0.1):   ", np.round(precision_score(ytrain, LR_Grid.predict(Xtrain)), decimals=3))

print("------Test data-------------------------------------------------------")

print("RECALL Test data (new_threshold = 0.1):        ", np.round(recall_score(ytest, ytest_pred), decimals=3))
print("PRECISION Test data (new_threshold = 0.1):     ", np.round(precision_score(ytest, ytest_pred), decimals=3))
print()
print("The Confusion Matrix Test data (new_threshold = 0.1):-----------------")
print(confusion_matrix(ytest, ytest_pred))
print("----------------------------------------------------------------------")
print(classification_report(ytest, ytest_pred))

# WYKRES-------------------------------------------
y_pred_proba = LR_Grid.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest,  y_pred_proba)
auc = metrics.roc_auc_score(ytest, y_pred_proba)
plt.plot(fpr, tpr, label='Logistic Regression (auc = 
plt.axvline(0.1, color = '#00C251', linestyle = '--', label = 'threshold = 0.1')
plt.axvline(0.5, color = 'grey', linestyle = '--', label = 'threshold = 0.5')
plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')

plt.show()

 

Zmiana progu w modelu spowodowanej wzrost 'recall' na zbiorze treningowym z poziomu 0.65 do poziomu 0.81. Stało się na kosztem precyzji, który uległby pogorszeniu z pierwotnego poziomu 0.77 do poziomu 0.54.

Next part:

Model regresji Logistyczne. Część 4: Zastosowanie class_weight

Zastosowanie class_weight jest sposobem na poprawę wskaźnika recall w zbiorach wyników wysoko niezbilansowanych. Podniesienie wskaźnika recall wiąże się ze spadkiem poziomu wskaźnika precision.

W poprzednich częściach omówiliśmy jak przygotowywać dane i jak tworzyć model regresji logistycznej. Mówiliśmy również o tym, w jaki sposób zmienić ilość danych, tak aby zmniejszyć wpływ niezbilansowania w zbiorze treningowym podczas tworzenia modelu regresji logistycznej.

Wcześniejsze części można znaleźć pod tymi adresami:

Przykład Modelu Regresji Logistycznej. Część 1: model podstawowy

Model Regresji Logistycznej. Część 2: Oversampling

Model Regresji Logistycznej. Część 3: zmiana progu w modelu regresji logistycznej

Zastosowanie class_weight

Wspominaliśmy we wcześniejszych wpisach, że zbiór zmiennych zależnych jest wysoko niezbilansowany. Na jedną zmienną wynikową klasy 1 w zbiorze treningowym przypada 216 zmiennych klasy 0. Aby ograniczyć znaczenie tej dysproporcji należy podnieść wagę zmiennej zależnej o około 216 razy.

Pw = sum(ytrain == 0) / sum(ytrain == 1)  # size to repeat y == 1
Pw = np.round(Pw, decimals=0)
Pw = Pw.astype(int)
Pw

Parametr eagowy positive weight, Pw = 216.

Występowanie klasy 0 w zbiorze testowym zmiennych zależnych jest 216 razy częstsza niż 1. Należy zatem zwiększyć parametr class_weight  dla klasy 1, w stosunku do klasy 0 według przedziału {0:1,1:216}.

Parameters = {'C': np.power(10.0, np.arange(-3, 3))}
LogReg = LogisticRegression(class_weight = {0 : 1, 1 : Pw}, warm_start = True, solver='lbfgs')

Dostrojenie modelu za pomocą siatki Grid.

LRV_Reg_grid = GridSearchCV(LogReg, param_grid = Parameters, scoring = 'roc_auc', n_jobs = 5, cv = 6)

LRV_Reg_grid.fit(Xtrain, ytrain)

Z ciekawości zbadamy jakie zostały wybrane hiperparametry.

print("The Best parameter:",LRV_Reg_grid.best_params_)
print("The Best estimator:",LRV_Reg_grid.best_estimator_)

Wstawiam moduł diagnostyczny.

print()
print("Recall Training data:     ", np.round(recall_score(ytrain, LRV_Reg_grid.predict(Xtrain)), decimals=4))
print("Precision Training data:  ", np.round(precision_score(ytrain, LRV_Reg_grid.predict(Xtrain)), decimals=4))

print("----------------------------------------------------------------------")
print("Recall Test data:         ", np.round(recall_score(ytest, LRV_Reg_grid.predict(Xtest)), decimals=4)) 
print("Precision Test data:      ", np.round(precision_score(ytest, LRV_Reg_grid.predict(Xtest)), decimals=4))
print("----------------------------------------------------------------------")
print("Confusion Matrix Test data")
print(confusion_matrix(ytest, OVS_grid.predict(Xtest)))


print("----------------------------------------------------------------------")
print(classification_report(ytest, LRV_Reg_grid.predict(Xtest)))

y_pred_proba = LRV_Reg_grid.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest,  y_pred_proba)
auc = metrics.roc_auc_score(ytest, y_pred_proba)
plt.plot(fpr, tpr, label='Logistic Regression (auc = 
plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()

Zastosowanie class_weight spowodowało podniesienie wagi zmiennych zależnych w klasie 1. Dzięki temu model regresji logistycznej zwiększył wskaźnik recall dla klasy 1 do poziomu 0.92 kosztem precision wynoszącym 0.35 dla tej klasy.

Parameters = {'C': np.power(10.0, np.arange(-3, 3))}
LogReg = LogisticRegression(class_weight = {0 : 1, 1 : Pw}, warm_start = True, solver='lbfgs')
LRV_Reg_grid = GridSearchCV(LogReg, param_grid = Parameters, scoring = 'roc_auc', n_jobs = 5, cv = 6)
LRV_Reg_grid.fit(Xtrain, ytrain)

print()
print("Recall Training data:     ", np.round(recall_score(ytrain, LRV_Reg_grid.predict(Xtrain)), decimals=4))
print("Precision Training data:  ", np.round(precision_score(ytrain, LRV_Reg_grid.predict(Xtrain)), decimals=4))

print("----------------------------------------------------------------------")
print("Recall Test data:         ", np.round(recall_score(ytest, LRV_Reg_grid.predict(Xtest)), decimals=4)) 
print("Precision Test data:      ", np.round(precision_score(ytest, LRV_Reg_grid.predict(Xtest)), decimals=4))
print("----------------------------------------------------------------------")
print("Confusion Matrix Test data")
print(confusion_matrix(ytest, OVS_grid.predict(Xtest)))


print("----------------------------------------------------------------------")
print(classification_report(ytest, LRV_Reg_grid.predict(Xtest)))

y_pred_proba = LRV_Reg_grid.predict_proba(Xtest)[::,1]
fpr, tpr, _ = metrics.roc_curve(ytest,  y_pred_proba)
auc = metrics.roc_auc_score(ytest, y_pred_proba)
plt.plot(fpr, tpr, label='Logistic Regression (auc = 
plt.xlabel('False Positive Rate',color='grey', fontsize = 13)
plt.ylabel('True Positive Rate',color='grey', fontsize = 13)
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.legend(loc=4)
plt.plot([0, 1], [0, 1],'r--')
plt.show()

 

Dzisiaj omówimy przykład tworzenia zamówień automatycznych w piekarni. Użyjemy do tego modelu regresji logistycznej. Nie da się ukryć, że jest to nieco przestarzały sposób w środowisku machine learning. Niemniej model regresji liniowej jest klasyczną i często skuteczną metodą prognozowania wyników.  

Problem zamówień w sklepach piekarni, przykład tworzenia zamówień automatycznych

Nasza przykładowa sieć sprzedaży składa się z 16 sklepów sprzedających pieczywo. Sieć sklepów działa w małych miastach pod Warszawą.  Sklepy zlokalizowane są blisko dworców kolejowych skąd wielu mieszkańców dojeżdża do pracy do Warszawy. Idąc i wracając z pracy mieszkańcy kupują pieczywo. Na pierwszej zmianie piekarnia dostarcza do swoich sklepów maksymalną ilość produktów gdyż wie, że pieczywo zostanie w większości sprzedane w ciągu dnia . Problem pojawia się gdy trzeba uzupełnić zasoby sklepu przed szczytem powrotów z pracy, pomiędzy godzinami 14 a 18. Jeżeli piekarnia dostarczy zbyt wielu produktów na drugiej zmianie, nie zostaną one sprzedane i zostaną wyrzucone. Jeżeli na drugiej zmianie produktów będzie zbyt mało, z czasem mieszkańcy zniechęcą się do wstępowania do sklepu i spadnie sprzedaż. Teraz omówimy przykład tworzenia zamówień automatycznych opartych na starej, dobrej regresji liniowej.

Model regresji liniowej przewidującej dzienne zapotrzebowanie na produkty

Model zasilany będzie rocznym rejestrem sprzedaży. Zbiór danych zawiera datę sprzedaży, rodzaj asortymentu oraz informacje pogodowe w postaci: temperatury, ciśnienia atmosferycznego oraz opadów. W ocenie prowadzącego badania, dane meteorologiczne mogły mieć bezpośredni wpływ na wielkość zakupów w sklepach piekarni. Ściągamy bazę danych oraz potrzebne biblioteki. W tym ćwiczeniu wyjątkowo baza danych nie będzie dostępna.    

import pandas as pd
import numpy as np
import itertools
from itertools import chain, combinations
import statsmodels.formula.api as smf
import scipy.stats as scipystats
import statsmodels.api as sm
import statsmodels.stats.stattools as stools
import statsmodels.stats as stats 
from statsmodels.graphics.regressionplots import *
import matplotlib.pyplot as plt
import seaborn as sns
import copy
#from sklearn.cross_validation import train_test_split
import math


df = pd.read_csv('c:/1/BazaPiekarni.csv', parse_dates=['Time'])
df.sample(5)

Sprawdzamy jak wielki jest zbiór danych. Zbiór zawiera 1 mln 48 tysięcy transakcji. Duża liczba rekordów dobrze rokuje przy tworzeniu modelu.

df.shape

(1048575, 9)

Sprawdźmy jaki jest format naszych danych. Dzięki zastosowaniu parametru  parse_dates=[’Time’] ) udało się zachować format daty w kolumnie ‘Time’.

df.dtypes

Teraz zmienimy nazwy kolumn oraz kasujemy kolumny ‘index’ i ‘Number’

df.columns

 

df.columns = ['Number', 'index', 'Date', 'Assortment_code', 'Assortment_name', 'Location', 'Temperature', 'Weather', 'Pressure']

del df['index']
del df['Number']
df.sample(5)

Uporządkowane dane mają postać:

Dodajemy nowe kolumny porządkujące datę i czas.

df['Hour'] = df.Date.dt.hour
df['Weekday'] = df.Date.dt.weekday_name
df['Date2'] = df.Date.dt.date
df.sample(4)

Problematyczna druga połowa dnia, druga zmiana, zaczyna się o godzinie 14. Naszym celem jest określenie jaka powinna być wielkość dostaw poszczególnych asortymentów. Powinnyśmy wybrać jedną z lokalizacji następnie wybrać dane sprzedaży tylko po godzinie 14. Należy również wybrać jeden produkt.

Sprawdzamy do jakiej godziny sprzedawane jest pieczywo.

df.Hour.max()

18

Wydzielamy dane tylko dla sklepu nr 7 i tylko po godzinie 14.

df7 = df[(df['Hour']>=14)&(df['Hour']<=18)&(df['Location']==7)&(df['Assortment_code']==1)]
df7.sample(5)

Z danych została wyodrębniona tabela danych zawierająca sprzedaż chleba: ‘Primary Bread’ w sklepie numer 7 i tylko po godzinie 14.

Teraz zliczamy ile sztuk asortymentów pieczywa zostało sprzedanych w tej lokalizacji każdego dnia. Baza zbudowana jest tak, że jeden rekord reprezentuje jedną sprzedaż. Nasz model ma pokazywać ile sztuk pieczywa zostanie  sprzedanych w określonym czasie. Aby zsumować sprzedaż tworzymy tabelę przestawną.

kot = df7.pivot_table(index=['Assortment_name','Assortment_code','Date2','Weather','Temperature','Pressure','Location', 'Weekday'], values='Date',aggfunc='count')

kot.head()

Teraz przerabiam tabelę przestawną na zwykłą tabele danych dataframe, sortujemy dane.

df7 = kot.reset_index()
df7.sort_values('Date2', ascending = True, inplace=True )
df7.head(5)

Kolumnę ze zmiennymi wynikowymi nazwiemy 'Quantity sold’.

df7.rename(columns={'Date':'Quantity_sold'},inplace=True)
df7.sample(3)

Regresja jednoczynnikowa

Pierwszymi modelami stosowanymi do prognozowania były proste jednoczynnikowe modele regresji liniowej.

Aby zbudować przykładowy jednoczynnikowy model regresji liniowej trzeba znaleźć niezależną zmienną, która posiada największy związek liniowy ze zmienną zależną: 'Quantity sold’.

Żeby to jednak zrobić, trzeba najpierw zakodować wszystkie kolumny, które obecnie są wyrażone w formie tekstu. W naszym przykładzie takimi kolumnami są ‘Weather’ i ‘Weekday’

Przy okazji okazało się, że straciliśmy format daty w kolumnie ‘date2’. Naprawiamy to.

df7['Date2']= pd.to_datetime(df7.Date2)
df7.dtypes

Teraz możemy utworzyć nowe kolumny z cyfrową wersją tekstu.

df7['Weather_code'] = pd.Categorical(df7['Weather']).codes
df7['Weekday_code'] = df7['Date2'].dt.weekday

Teraz tworzę wektor korelacji między zmiennymi niezależnymi a zmienną zależną.

CORREL = df7.corr().sort_values('Quantity_sold')
CORREL['Quantity_sold']

Podstawowym argumentem do zastosowania modelu regresji liniowej jest istnienie wyraźnego związku liniowego pomiędzy zmienną zależną i zmienną niezależną.

W naszym przypadku zmienna niezależna ‘Weekday_code’ ma wyraźną korelację ze zmienną zależną.

Sprawdzimy teraz korelację wszystkich zmiennych.

sns.heatmap (df7.corr (), cmap="coolwarm")

Jednoczynnikowy model regresji liniowej

Wprowadzamy równanie regresji liniowej oraz kod umożliwiający wizualizację przebiegu linii regresji.

lm = smf.ols(formula = 'Quantity_sold ~ Weekday_code', data = df7).fit()
print(lm.summary())


### wykres--------------------------------------###
plt.figure()
plt.scatter(df7.Weekday_code, df7.Quantity_sold, c = 'grey')
plt.plot(df7.Weekday_code, lm.params[0] + lm.params[1] * df7.Weekday_code, c = 'r')
plt.xlabel('Weekday_code')
plt.ylabel('Quantity_sold')
plt.title("Linear Regression Plot")

Model regresji liniowej okazał się względnie słaby z uwagi na niski poziom wskaźnika R2 (R-squared) wynoszący 0.424

 

Wieloczynnikowy model regresji liniowej

lm = smf.ols(formula = 'Quantity_sold ~ Weekday_code + Pressure + Weather_code + Temperature', data = df7).fit()
print (lm.summary())

Model wielorakiej regresji liniowej nie okazał się lepszy. Jego wskaźnik wyniósł 0,432

Mimo istnienia związku liniowego między zmienną niezależną i zmienną zależną nie udało się stworzyć modelu pozwalającego wiarygodnie szacować przyszły poziom zakupów w sklepach piekarni. Aby model był efektywny należy rozejrzeć się za innym zestawem zmiennych niezależnych, które w leszy sposób opiszą rzeczywistość.

 

Praktyczne użycie modelu regresji wielorakiej jako przykład tworzenia zamówień automatycznych 

Praca nad modelem, którego nie można wykorzystać jest pracą jałową. Nie udało nam się stworzyć dobrego modelu ale nic nie stoi na przeszkodzie aby pokazać jak nasz model jest zły.

Na początek możemy ręcznie przekleić parametry modelu tworząc nową kolumnę.

df7['Model_Reg'] = (87.6337) +(-5.8891*df7['Weekday_code']) +(-0.0478*df7['Pressure']) +(0.6384*df7['Weather_code'])+(0.0236*df7['Temperature'])
df7['Model_Reg']= np.round(df7['Model_Reg'], decimals=0)
df7[['Quantity_sold','Model_Reg']].head()

 Widać, że model nie jest zbyt dokładny.

 

Uruchomienie modelu regresji liniowej

Na przyszłość trudno oczekiwać, że za każdym razem będziemy przeklejali parametry modelu. Dlatego warto tą czynność zautomatyzować.

Tworzymy słownik współczynników.

coef = lm.params.to_dict()

Teraz możemy sobie przywołać dowolny współczynnik przy x.

coef['Weekday_code']

-5.889075106403816

coef['Intercept']

87.6336717107532

Teraz w oddzielnej kolumnie utworzymy kod tworzący równanie regresji.

df7['Model_Reg2'] = (87.6337) +(coef['Weekday_code']*df7['Weekday_code']) +(coef['Pressure']*df7['Pressure']) +(coef['Weather_code']*df7['Weather_code'])+(coef['Temperature']*df7['Temperature'])
df7['Model_Reg2']= np.round(df7['Model_Reg2'], decimals=0)
df7[['Quantity_sold','Model_Reg','Model_Reg2']].head()

Jak widać model nie jest w stanie przewidzieć właściwej ilością produktów.

Teraz sprawdzamy o ile różnią się estymacje modelu.

 

 Part one: preliminary graphical analysis to research of coefficients dependence 

Machine learning tools

Thanks using predictive and classification models for the area of machine learning tools is possible significant decrease cost of the verification laboratory research.

Costs of empirical verification are counted to the Technical cost of production. In production of some chemical active substantiation is necessary to lead laboratory empirical classification to allocate product to separated class of quality.

This research can turn out very expensive.  In the case of short runs of production, cost of this classification can make all production unprofitable.

With the help can come machine learning tools, who can replace expensive laboratory investigation by theoretical judgment.

Application of effective prediction model can decrease necessity of costly empirical research to the reasonable minimum.

Manual classification would be made in special situation where mode would be ineffective or in case of checking process by random testing.

Case study: laboratory classification of active chemical substance Poliaxid

We will now follow process of making model of machine learning based on the classification by the Random Forest method. Chemical plant produces small amounts expensive chemical substance named Poliaxid. This substance must meet very rigorous quality requirements. For each charge have to pass special laboratory verification. This empirical trials are expensive and long-lasting. Their cost significantly influence on the overall cost of production. Process of Poliaxid production is monitored by many gauges. Computer save eleven variables such trace contents of some chemical substances, acidity and density of the substance. There are remarked the level of some of the collected coefficients have relationship with result of the end quality classification. Cause of effect relationship drive to the conclusion — it is possible to create classification model to explain overall process. In this case study we use base, able to download from this address: source

This base contains results of 1593 trials and eleven coefficients saved during the process for each of the trial.

import pandas as pd
import numpy as np

df = pd.read_csv('c:/2/poliaxid.csv', index_col=0)
del df['nr.']
df.head(5)

In the last column named: “quality class” we can find results of the laboratory classification.

Classes 1 and 0 mean the best quality of the substance. Results 2, 3 and 4 means the worst quality.

Before we start make machine learning model we ought to look at the data. We do it thanks matrix plots. These plots show us which coefficient is good predictor, display overall dependencies between exogenic and endogenic ratios.

Graphical analysis to research of coefficients dependence

The action that should precede the construction of the model should be graphical overview.

In this way we obtain information whether model is possible to do.

First we ought to divide results from result column: “quality class” in to two categories: 'First' and 'Second'.

df['Qual_G'] = df['quality class'].apply(lambda x: 'First' if x < 2 else 'Second')
df.sample(3)

At the end of table appear new column: "Qual_G".

Now we create vector of correlation between independent coefficients and result factor in column: 'quality class'.

CORREL = df.corr().sort_values('quality class')
CORREL['quality class']

Correlation vector points significant influences exogenic factors on the results of empirical classification.

We chose most effective predictors among all eleven variables. We put this variables in to the matrix correlation plot.

This matrix plot contain two colors. Blue dots means firs quality. Thanks to this all dependencies is clearly displayed.

import seaborn as sns

sns.pairplot(data=df[['factorB', 'citric catoda','sulfur in nodinol', 'noracid', 'lacapon','Qual_G']], hue='Qual_G', dropna=True)

Matrix display clearly patterns of dependencies between variables. Easily see part of coefficients have significant impact on the classification the first or second quality class.

Dichotomic division is good to display dependencies. Let's see what happen when we use division for 5 class of quality. We use this classes that was made by laboratory. We took only two most effective predictors. Despite this plot is illegible.

In the next part of this letter we use machine learning tools to make theoretical classification.

Next part:

Estimation of the result of the empirical research with machine learning tools (part 2)

 Artificial intelligence in process of classification 

In first part of this publication described the problem of additional classification of the quality classes. Every charge of Poliaxid have to go through rigoristic, expensive test to classification to the proper class of quality. [Source of data]

In last study we showed that some quantity factors associated with production have significant impact on the final quality of the substance.

 Existing correlation lead to the conclusion that it is possible effective model of artificial intelligence is applied 

It leads to the two conclusions:

• Laborious method of classification could be replaced by theoretical model.
• Persons who monitor production process could be informed by the model about probability of final quality of the substance.

Machine learning procedure allows us make try to build such model.

We open the base in Python.

import pandas as pd
import numpy as np

df = pd.read_csv('c:/2/poliaxid.csv', index_col=0)
df.head(5)

We divide set of data in to the independent variables X and dependent variable y, the result of the process.

X = df.drop('quality class', axis=1) 
y = df['quality class']    

Now we divide database into the training and test underset.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=123,stratify=y)

Pipeline merge standardization and estimation. We took as the estimation method of Random Forest.

from sklearn.pipeline import make_pipeline
from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor

pipeline = make_pipeline(preprocessing.StandardScaler(),
    RandomForestRegressor(n_estimators=100))

Hyperparameters of the random forest regression are declared.

hyperparameters = {'randomforestregressor__max_features': ['auto', 'sqrt', 'log2'],
                   'randomforestregressor__max_depth': [None, 5, 3, 1]}

Tune model using cross-validation pipeline.

from sklearn.model_selection import GridSearchCV
clf = GridSearchCV(pipeline, hyperparameters, cv=10)
clf.fit(X_train, y_train)

Random forest is the popular method using regression engine to obtain result.

Many scientists think that this is incorrect. Andrew Ng, in Machine Learning course at Coursers, explains why this is a bad idea - see his Lecture 6.1 - Logistic Regression | Classification at YouTubee. https://www.youtube.com/watch?v=-la3q9d7AKQ&t=0s&list=PLLssT5z_DsK-h9vYZkQkYNWcItqhlRJLN&index=33

I, as an apprentice, will lead this model to the end. Without this rounding Confusion Matrix would be impossible to use because y from the test set has discrete form but predicted y would be in format continuous.

Here we have array with the result of prediction our model. You can see continuous form of result.

y_pred

Empirical result has discrete form.

y.value_counts()

We make rounding continuous data to the discrete form.

y_pred = clf.predict(X_test)
y_pred = np.round(y_pred, decimals=0)

Typical regression equation should not be used to the classification, but logistic regression seems to can make classification.

This is occasion to compare linear regression, logistic regression and typical tool used to classification Support Vector Machine.

Now we make evaluation of the model. We use confusion matrix.

from sklearn.metrics import classification_report, confusion_matrix
from sklearn import metrics

co_matrix = metrics.confusion_matrix(y_test, y_pred)
co_matrix

print(classification_report(y_test, y_pred))

Regression Random Forest with a temporary adaptation to discrete results seems to be good!

According to the f1-score ratio, model of artificial intelligence can good classify for these classes which have many occurrences.

For example 0 class has 13 occurrence and model can't judge this class. In opposite to the class 0 is class 1. There are 136 test values and model can properly judge classes in  78

In next part of this investigation we will test models of artificial intelligence intended to the make classification.

Next part:

Estimation of the result of the empirical research with machine learning tools. Classification with SVM Support Vector Machine (part 3)

This time we use model which is designed to classification application.

The SVM Support Vector Machine algorithm is included among the learning machine estimators based on the classification and regression analysis processes.

The SVM classifier uses an optimization algorithm based on maximizing the margin of the hyperplan. The SVM algorithm is designed to conduct the best possible classification of results. Vectors separating hyperspace can be linear or (thanks to the SVC function) non-linear.

In our model, we will use the linear SVM Support Vector Machine classifier.

We download all needed libraries and database file.

import pandas as pd 
import numpy as np 
import matplotlib.pyplot as plt
import seaborn as sns
import pprint

from sklearn.pipeline import Pipeline
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.externals import joblib

df = pd.read_csv('c:/2/poliaxid.csv', index_col=0)
del df['nr.']
df.head(3)

Next we point the column y with the result of the calculations, and columns with independent variables X.

X=df.drop(['quality class'],axis=1)
Y=df['quality class']

Pipeline put together standardization and classification.

ew = [('scaler', StandardScaler()), ('SVM', SVC())]
pipeline = Pipeline(ew)

parameteres = {'SVM__C':[0.001,0.1,10,100,10e5], 'SVM__gamma':[0.1,0.01]}
X_train, X_test, y_train, y_test = train_test_split(X,Y,test_size=0.2, random_state=30, stratify=Y)
grid = GridSearchCV(pipeline, param_grid=parameteres, cv=5)
grid.fit(X_train, y_train)
print("score = 

I can see which superparamiters was chosen by the grid as the best.

pparam=pprint.PrettyPrinter(indent=2)
print(grid.best_params_)

y_pred = grid.predict(X_test)

Classificator is evaluation by confusion matrix.

from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred)) 

The SVM Support Vector Machine is not better clasificator than not adapted to such a role Random Forest regression.