Regresja liniowa TensorFlow z funkcją Facet & Termin interakcji

W tym samouczku dowiesz się, jak sprawdzić dane i przygotować je do utworzenia prostego zadania regresji liniowej.

Ten samouczek jest podzielony na dwie części:

• Poszukaj interakcji
• Przetestuj model

W poprzednim samouczku do oszacowania mediany ceny domu użyto zbioru danych Boston. Zbiór danych Boston ma niewielki rozmiar i zawiera tylko 506 obserwacji. Ten zbiór danych jest uważany za punkt odniesienia do wypróbowania nowych algorytmów regresji liniowej.

Zbiór danych składa się z:

Zmienna	Opis
zn	Odsetek terenów mieszkalnych przeznaczonych na działki powyżej 25 000 stóp kwadratowych.
indus	Udział niedetalicznych akrów biznesowych przypadających na miasto.
nox	stężenie tlenków azotu
rm	średnia liczba izb w mieszkaniu
wiek	odsetek lokali okupowanych przez właścicieli zbudowanych przed 1940 r
dis	odległości ważone do pięciu centrów pracy w Bostonie
podatek	pełnowartościowa stawka podatku od nieruchomości na 10000 dolarów
ptratio	stosunek liczby uczniów do nauczycieli według miasta
medv	Średnia wartość domów zajmowanych przez właścicieli w tysiącach dolarów
crim	wskaźnik przestępczości na mieszkańca według miast
chas	Fikcyjna zmienna Charles River (1 jeśli ogranicza rzekę; 0 w przeciwnym razie)
b	odsetek czarnych w mieście

W tym samouczku oszacujemy medianę ceny za pomocą regresora liniowego, ale skupiamy się na jednym konkretnym procesie uczenia maszynowego: „przygotowaniu danych”.

Model uogólnia wzór w danych. Aby uchwycić taki wzór, musisz go najpierw znaleźć. Dobrą praktyką jest przeprowadzenie analizy danych przed uruchomieniem dowolnego algorytmu uczenia maszynowego.

Wybór odpowiednich funkcji decyduje o sukcesie Twojego modelu. Wyobraź sobie, że próbujesz oszacować wynagrodzenie ludzi, jeśli nie uwzględnisz płci jako współzmiennej, otrzymasz kiepskie oszacowanie.

Innym sposobem ulepszenia modelu jest przyjrzenie się korelacji między zmienną niezależną. Wracając do przykładu, możesz myśleć o edukacji jako o doskonałym kandydacie do przewidywania zarobków, ale także zawodu. Można powiedzieć, że zawód zależy od poziomu wykształcenia, a mianowicie wyższe wykształcenie często prowadzi do lepszego zawodu. Jeśli uogólnimy tę ideę, możemy powiedzieć, że korelacja między zmienną zależną a zmienną objaśniającą może zostać powiększona o jeszcze jedną zmienną objaśniającą.

Aby uchwycić ograniczony wpływ wykształcenia na zawód, możemy użyć terminu interakcji.

Jeśli spojrzysz na równanie płac, wygląda to następująco:

Jeśli jest dodatnia, oznacza to, że dodatkowy poziom wykształcenia skutkuje wyższym wzrostem mediany wartości domu przy wysokim poziomie zajętości. Innymi słowy, istnieje efekt interakcji między wykształceniem a zawodem.

W tym samouczku postaramy się sprawdzić, które zmienne mogą być dobrym kandydatem do terminów interakcji. Sprawdzimy, czy dodanie tego rodzaju informacji prowadzi do lepszego przewidywania cen.

W tym samouczku dowiesz się

• Statystyki podsumowujące
• Omówienie aspektów
• Fasety głębokie nurkowanie
• Zainstaluj Facet
• Przegląd
• Wykres
• Fasety głębokie nurkowanie
• TensorFlow
• Dane przygotowawcze
• Regresja podstawowa: wzorcowa
• Ulepsz model: Termin interakcji

Statystyki podsumowujące

Przed przystąpieniem do modelowania można wykonać kilka czynności. Jak wspomniano wcześniej, model jest uogólnieniem danych. Najlepszą praktyką jest zrozumienie danych i zrobienie prognozy. Jeśli nie znasz swoich danych, masz niewielkie szanse na ulepszenie swojego modelu.

Najpierw załaduj dane jako ramkę danych pandy i utwórz zestaw uczący i zestaw testowy.

Wskazówki: w tym samouczku musisz mieć zainstalowany w Pythonie matplotlit i seaborn. Możesz zainstalować pakiet Pythona w locie za pomocą Jupyter. Nie powinieneś tego robić

!conda install -- yes matplotlib

ale

import sys!{sys.executable} -m pip install matplotlib # Already installed!{sys.executable} -m pip install seaborn

Pamiętaj, że ten krok nie jest konieczny, jeśli masz zainstalowane oprogramowanie matplotlib i seaborn.

Matplotlib to biblioteka do tworzenia wykresów w Pythonie. Seaborn to biblioteka wizualizacji statystycznych zbudowana na bazie matplotlib. Zapewnia atrakcyjne i piękne działki.

Poniższy kod importuje niezbędne biblioteki.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tffrom sklearn.datasets import load_bostonimport numpy as np

Biblioteka sklearn zawiera zestaw danych Boston. Możesz wywołać jego API, aby zaimportować dane.

boston = load_boston()df = pd.DataFrame(boston.data) 

Nazwa funkcji jest przechowywana w obiekcie nazwy_funkcji w tablicy.

boston.feature_names

Wynik

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Możesz zmienić nazwy kolumn.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Konwertujesz zmienną CHAS na zmienną łańcuchową i oznaczasz ją tak, jeśli CHAS = 1 i nie, jeśli CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
W przypadku pand podzielenie zbioru danych jest proste. Losowo dzielisz zbiór danych z 80-procentowym zestawem uczącym i 20-procentowym zestawem testowym. Pandy mają wbudowaną funkcję kosztu do dzielenia próbki ramki danych.


Pierwszy parametr frac ma wartość od 0 do 1. Ustawiasz ją na 0,8, aby wybrać losowo 80 procent ramki danych.
Random_state pozwala na zwrócenie tej samej ramki danych dla wszystkich.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Możesz uzyskać kształt danych. Powinno być:

Skład pociągu: 506 * 0,8 = 405
Zestaw testowy: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Wynik 
(405, 14) (101, 14) 
 
df_test.head(5)
Wynik
 

 
 
 
 
PRZESTĘPSTWO 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
WIEK 
 
DIS 
 
RAD 
 
PODATEK 
 
PTRATIO 
 
b 
 
LSTAT 
 
CENA £ 
 

 
 
0 
 
0,00632 
 
18,0 
 
2.31 
 
Nie 
 
0.538 
 
6.575 
 
65.2 
 
4.0900 
 
1.0 
 
296,0 
 
15.3 
 
396,90 
 
4.98 
 
24,0 
 

 
 
1 
 
0,02731 
 
0.0 
 
7.07 
 
Nie 
 
0,469 
 
6.421 
 
78.9 
 
4,9671 
 
2.0 
 
242,0 
 
17.8 
 
396,90 
 
9.14 
 
21.6 
 

 
 
3 
 
0,03237 
 
0.0 
 
2.18 
 
Nie 
 
0,458 
 
6.998 
 
45.8 
 
6.0622 
 
3.0 
 
222,0 
 
18.7 
 
394,63 
 
2,94 
 
33.4 
 

 
 
6 
 
0,08829 
 
12.5 
 
7.87 
 
Nie 
 
0.524 
 
6.012 
 
66.6 
 
5.5605 
 
5.0 
 
311,0 
 
15.2 
 
395,60 
 
12.43 
 
22.9 
 

 
 
7 
 
0,14455 
 
12.5 
 
7.87 
 
Nie 
 
0.524 
 
6.172 
 
96.1 
 
5.9505 
 
5.0 
 
311,0 
 
15.2 
 
396,90 
 
19.15 
 
27.1 
 

 

 

Dane są nieuporządkowane; jest często niezrównoważony i pokryty wartościami odstającymi, które odrzucają analizę i szkolenie w zakresie uczenia maszynowego.
Pierwszym krokiem do oczyszczenia zbioru danych jest zrozumienie, gdzie należy go wyczyścić. Czyszczenie zbioru danych może być trudne, zwłaszcza w dowolny sposób, który można uogólnić
Zespół Google Research opracował narzędzie do tego zadania o nazwie Facets, które pomaga wizualizować dane i wycinać je na różne sposoby. To dobry punkt wyjścia, aby zrozumieć, w jaki sposób zestaw danych jest ułożony.
Aspekty pozwalają ci dowiedzieć się, gdzie dane nie wyglądają tak, jak myślisz.
Oprócz aplikacji internetowej Google ułatwia osadzenie zestawu narzędzi w notatniku Jupyter.
Aspekty składają się z dwóch części:

Omówienie aspektów


Fasety głębokie nurkowanie


Omówienie aspektów
Omówienie aspektów zawiera przegląd zestawu danych. Omówienie aspektów dzieli kolumny danych na wiersze zawierające istotne informacje

procent brakujących obserwacji
wartości minimalne i maksymalne
statystyki, takie jak średnia, mediana i odchylenie standardowe.
Dodaje również kolumnę, która pokazuje procent wartości, które są zerami, co jest pomocne, gdy większość wartości to zera.
Możliwe jest wyświetlenie tych rozkładów w zestawie danych testowych, a także w zestawie uczącym dla każdej funkcji. Oznacza to, że możesz dwukrotnie sprawdzić, czy test ma podobny rozkład do danych szkoleniowych.

Jest to przynajmniej minimum do wykonania przed jakimkolwiek zadaniem uczenia maszynowego. Dzięki temu narzędziu nie przegapisz tego kluczowego kroku, który podkreśla pewne nieprawidłowości.

Fasety głębokie nurkowanie
Facets Deep Dive to fajne narzędzie. Pozwala to uzyskać pewną przejrzystość zbioru danych i powiększyć maksymalnie, aby zobaczyć pojedynczy fragment danych. Oznacza to, że możesz łączyć dane według wiersza i kolumny w dowolnej funkcji zestawu danych.
Będziemy używać tych dwóch narzędzi z zestawem danych Boston.
Uwaga : nie możesz jednocześnie korzystać z Przeglądu aspektów i Głębokiego nurkowania aspektów. Aby zmienić narzędzie, musisz najpierw wyczyścić notatnik.

Zainstaluj Facet
Do większości analiz można używać aplikacji internetowej Facet. W tym samouczku zobaczysz, jak używać go w notatniku Jupyter.
Przede wszystkim musisz zainstalować nbextensions. Robi się to za pomocą tego kodu. Kopiujesz i wklejasz następujący kod w terminalu swojej maszyny.
pip install jupyter_contrib_nbextensions 
Zaraz po tym musisz sklonować repozytoria na swoim komputerze. Masz dwie możliwości:
Opcja 1) Skopiuj i wklej ten kod w terminalu (zalecane)
Jeśli nie masz zainstalowanego Git na swoim komputerze, przejdź do tego adresu URL https://git-scm.com/download/win i postępuj zgodnie z instrukcjami. Gdy skończysz, możesz użyć polecenia git w terminalu dla użytkownika Mac lub zachęty Anaconda dla użytkownika systemu Windows
git clone https://github.com/PAIR-code/facets 
Opcja 2) Wejdź na https://github.com/PAIR-code/facets i pobierz repozytoria.

Jeśli wybierzesz pierwszą opcję, plik znajdzie się w pobranym pliku. Możesz pozwolić na pobranie pliku lub przeciągnąć go do innej ścieżki.
Możesz sprawdzić, gdzie są przechowywane aspekty za pomocą tego wiersza poleceń:
echo `pwd`/`ls facets` 
Teraz, gdy zlokalizowałeś Facets, musisz zainstalować go w Jupyter Notebook. Musisz ustawić katalog roboczy na ścieżkę, w której znajdują się aspekty.
Twój obecny katalog roboczy i lokalizacja ZIP Facets powinny być takie same.

Musisz wskazać katalog roboczy Facet:
cd facets
Aby zainstalować Facets w Jupyter, masz dwie opcje. Jeśli zainstalowałeś Jupyter z Conda dla wszystkich użytkowników, skopiuj ten kod:
może użyć jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
W przeciwnym razie użyj:
jupyter nbextension install facets-dist/ --user
W porządku, wszystko gotowe. Otwórzmy Omówienie aspektów.

Przegląd
Przegląd używa skryptu Python do obliczania statystyk. Musisz zaimportować skrypt o nazwie generic_feature_statistics_generator do Jupyter. Nie martw się; skrypt znajduje się w plikach aspektów.
Musisz zlokalizować jego ścieżkę. Jest to łatwe do zrobienia. Otwierasz fasety, otwierasz plik facets_overview, a następnie python. Skopiuj ścieżkę

Następnie wróć do Jupyter i napisz następujący kod. Zmień ścieżkę „/ Users / Thomas / facets / facets_overview / python” na swoją ścieżkę.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Możesz zaimportować skrypt za pomocą poniższego kodu.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
W systemie Windows ten sam kod staje się
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Aby obliczyć statystyki funkcji, musisz użyć funkcji GenericFeatureStatisticsGenerator () i użyć obiektu ProtoFromDataFrames. Możesz przekazać ramkę danych w słowniku. Na przykład, jeśli chcemy stworzyć statystykę podsumowującą dla zestawu pociągów, możemy przechowywać informacje w słowniku i wykorzystać je w obiekcie `` ProtoFromDataFrames``


'name': 'train', 'table': df_train 

Nazwa to nazwa wyświetlanej tabeli i używasz nazwy tabeli, dla której chcesz obliczyć podsumowanie. W Twoim przykładzie tabela zawierająca dane to df_train
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overviewimport base64gfsg = GenericFeatureStatisticsGenerator()proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},{'name': 'test', 'table': df_test}])#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")
Na koniec wystarczy skopiować i wkleić poniższy kod. Kod pochodzi bezpośrednio z GitHub. Powinieneś być w stanie to zobaczyć:

# Display the facets overview visualization for this data# Displfrom IPython.core.display import display, HTMLHTML_TEMPLATE = """
"""html = HTML_TEMPLATE.format(protostr=protostr)display(HTML(html))
 
Wykres
Po sprawdzeniu danych i ich dystrybucji można wykreślić macierz korelacji. Macierz korelacji oblicza współczynnik Pearsona. Współczynnik ten jest powiązany między -1 a 1, przy czym wartość dodatnia oznacza korelację dodatnią, a wartość ujemna korelację ujemną.
Chcesz zobaczyć, które zmienne mogą być dobrym kandydatem do terminów interakcji.
## Choose important feature and further check with Dive%matplotlib inlineimport matplotlib.pyplot as pltimport seaborn as snssns.set(style="ticks")# Compute the correlation matrixcorr = df.corr('pearson')# Generate a mask for the upper trianglemask = np.zeros_like(corr, dtype=np.bool)mask[np.triu_indices_from(mask)] = True# Set up the matplotlib figuref, ax = plt.subplots(figsize=(11, 9))# Generate a custom diverging colormapcmap = sns.diverging_palette(220, 10, as_cmap=True)# Draw the heatmap with the mask and correct aspect ratiosns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,square=True, linewidths=.5, cbar_kws={"shrink": .5})
Wynik 

png

Z macierzy widać:

LSTAT
RM

Są silnie skorelowane z PRICE. Kolejną ekscytującą cechą jest silna dodatnia korelacja między NOX i INDUS, co oznacza, że ​​te dwie zmienne poruszają się w tym samym kierunku. Poza tym są też skorelowane z CENĄ. DIS jest również silnie skorelowany z IND i NOX.
Masz pewną pierwszą wskazówkę, że IND i NOX mogą być dobrymi kandydatami do terminu przechwytującego, a DIS może być również interesujący, aby się na nim skupić.
Możesz pójść trochę głębiej, wykreślając siatkę par. Zilustruje bardziej szczegółowo mapę korelacji, którą wykreśliłeś wcześniej.
Siatka par, którą tworzymy, jest następująca:

Górna część: Wykres punktowy z dopasowaną linią
Przekątna: wykres gęstości jądra
Dolna część: Wielowymiarowy wykres gęstości jądra

Wybierasz skupienie się na czterech niezależnych zmiennych. Wybór odpowiada zmiennym o silnej korelacji z CENĄ

INDUS
NOX
RM
LSTAT

ponadto CENA.
Zwróć uwagę, że błąd standardowy jest dodawany domyślnie do wykresu punktowego.
attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]g = sns.PairGrid(df[attributes])g = g.map_upper(sns.regplot, color="g")g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)g = g.map_diag(sns.kdeplot)
Wynik 

Zacznijmy od górnej części:

Cena jest ujemnie skorelowana z INDUS, NOX i LSTAT; dodatnio skorelowane z RM.
Występuje niewielka nieliniowość w przypadku LSTAT i PRICE
Jest jak linia prosta, gdy cena jest równa 50. Z opisu zbioru danych, PRICE została obcięta do wartości 50

Przekątna

Wydaje się, że NOX ma dwa skupienia, jeden około 0,5 i jeden około 0,85.

Aby dowiedzieć się więcej na ten temat, zajrzyj do dolnej części. Wielowymiarowa gęstość jądra jest interesująca w tym sensie, że koloruje tam, gdzie znajduje się większość punktów. Różnica w stosunku do wykresu punktowego rysuje gęstość prawdopodobieństwa, mimo że w zbiorze danych nie ma punktu dla danej współrzędnej. Kiedy kolor jest silniejszy, wskazuje to na duże skupienie punktów wokół tego obszaru.
Jeśli sprawdzisz gęstość wielowymiarową dla INDUS i NOX, możesz zobaczyć dodatnią korelację i dwa skupienia. Przy udziale przemysłu powyżej 18, stężenie tlenków azotu przekracza 0,6.
Możesz pomyśleć o dodaniu interakcji między INDUSEM a NOX w liniowej zależności.
Wreszcie możesz skorzystać z drugiego narzędzia stworzonego przez Google, Facets Deep Dive. Interfejs jest podzielony na cztery główne sekcje. Środkowy obszar w środku to powiększalny wyświetlacz danych. W górnej części panelu znajduje się menu rozwijane, w którym można zmienić układ danych, aby sterować aspektami, pozycjonowaniem i kolorem. Po prawej stronie znajduje się szczegółowy widok określonego wiersza danych. Oznacza to, że możesz kliknąć dowolną kropkę danych w środkowej wizualizacji, aby wyświetlić szczegóły dotyczące tego konkretnego punktu danych.
Na etapie wizualizacji danych interesuje Cię szukanie korelacji parami między zmienną niezależną a ceną domu. Obejmuje jednak co najmniej trzy zmienne, a praca z wykresami 3D jest skomplikowana.
Jednym ze sposobów rozwiązania tego problemu jest utworzenie zmiennej kategorialnej. Oznacza to, że możemy stworzyć wykres 2D pokolorować kropkę. Możesz podzielić zmienną PRICE na cztery kategorie, przy czym każda kategoria jest kwartylem (tj. 0,25, 0,5, 0,75). Nazywasz tę nową zmienną Q_PRICE.
## Check non linearity with important featuresdf['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])## Show non linearity between RM and LSTATax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")


Fasety głębokie nurkowanie
Aby otworzyć Deep Dive, musisz przekształcić dane do formatu json. Pandy jako obiekt do tego. Możesz użyć to_json po zestawie danych Pandas.
Pierwsza linia kodu obsługuje rozmiar zbioru danych.
df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])sprite_size = 32 if len(df.index)>50000 else 64jsonstr = df.to_json(orient='records')
Poniższy kod pochodzi z Google GitHub. Po uruchomieniu kodu powinieneś być w stanie zobaczyć to:

# Display thde Dive visualization for this datafrom IPython.core.display import display, HTML# Create Facets templateHTML_TEMPLATE = """
"""# Load the json dataset and the sprite_size into the templatehtml = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)# Display the templatedisplay(HTML(html))
Chcesz sprawdzić, czy istnieje związek między kursem branżowym, stężeniem tlenku, odległością od urzędu pracy i ceną domu.
W tym celu najpierw podziel dane według zakresu branżowego i koloru za pomocą kwartylu ceny:

Wybierz faceting X i wybierz INDUS.
Wybierz Display i wybierz DIS. Będzie pokolorować kropki kwartylem ceny domu

tutaj ciemniejsze kolory oznaczają, że odległość do pierwszego miejsca pracy jest duża.
Jak dotąd ponownie pokazuje to, co wiesz, niższy wskaźnik branży, wyższa cena. Teraz możesz spojrzeć na podział według INDUX, według NOX.

Wybierz fasetowanie Y i wybierz NOX.

Teraz widać, że dom z dala od pierwszego ośrodka pracy ma najniższy udział w branży, a zatem najniższe stężenie tlenków. Jeśli zdecydujesz się wyświetlić typ z Q_PRICE i przybliżyć lewy dolny róg, możesz zobaczyć, jaki to rodzaj ceny.
Masz kolejną wskazówkę, że interakcja między IND, NOX i DIS może być dobrymi kandydatami do ulepszenia modelu.

TensorFlow
W tej sekcji oszacujesz klasyfikator liniowy za pomocą API estymatorów TensorFlow. Będziesz postępować w następujący sposób:

Przygotuj dane
Oszacuj model porównawczy: brak interakcji
Oszacuj model z interakcją

Pamiętaj, że celem uczenia maszynowego jest zminimalizowanie błędu. W takim przypadku wygra model z najmniejszym błędem średniokwadratowym. Estymator TensorFlow automatycznie oblicza tę metrykę.
Dane przygotowawcze
W większości przypadków musisz przekształcić swoje dane. Właśnie dlatego przegląd aspektów jest fascynujący. Ze statystyk podsumowujących wynika, że ​​istnieją wartości odstające. Te wartości mają wpływ na szacunki, ponieważ nie wyglądają jak populacja, którą analizujesz. Wartości odstające zwykle wpływały na wyniki. Na przykład dodatnia wartość odstająca ma tendencję do przeszacowywania współczynnika.
Dobrym rozwiązaniem tego problemu jest standaryzacja zmiennej. Standaryzacja oznacza odchylenie standardowe równe jeden i średnią zero. Proces normalizacji obejmuje dwa etapy. Przede wszystkim odejmuje średnią wartość zmiennej. Po drugie, dzieli przez wariancję, dzięki czemu rozkład ma wariancję jednostkową
Biblioteka sklearn jest pomocna w standaryzacji zmiennych. W tym celu można wykorzystać moduł przetwarzania wstępnego ze skalą obiektu.
Możesz użyć poniższej funkcji, aby skalować zbiór danych. Zwróć uwagę, że nie skalujesz kolumny etykiety ani zmiennych kategorialnych.
from sklearn import preprocessingdef standardize_data(df):X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']])X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'])df_scale = pd.concat([X_scaled_df,df['CHAS'],df['PRICE']],axis=1, join='inner')return df_scale
Możesz użyć tej funkcji do skonstruowania skalowanego pociągu / zestawu testowego.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Regresja podstawowa: wzorcowa
Przede wszystkim trenujesz i testujesz model bez interakcji. Celem jest zobaczenie metryki wydajności modelu.
Sposób uczenia modelu jest dokładnie taki, jak samouczek dotyczący interfejsu API wysokiego poziomu . Użyjesz estymatora TensorFlow LinearRegressor.
Przypominamy, że musisz wybrać:

funkcje do umieszczenia w modelu
przekształcić funkcje
skonstruować regresor liniowy
skonstruuj funkcję input_fn
wytrenuj model
przetestuj model

Używasz wszystkich zmiennych w zbiorze danych do trenowania modelu. W sumie istnieją el-poziomowe zmienne ciągłe i jedna zmienna kategorialna
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Konwertujesz elementy na kolumnę liczbową lub kategoryczną
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]
Tworzysz model za pomocą linearRegressor. Model przechowujesz w folderze train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Wynik 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Każda kolumna w pociągu lub danych testowych jest konwertowana na Tensor za pomocą funkcji get_input_fn
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']LABEL= 'PRICE'def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)
Szacujesz model na podstawie danych pociągu.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Wynik 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train_Boston/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 144.457INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)INFO:tensorflow:global_step/sec: 258.392INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)INFO:tensorflow:global_step/sec: 227.998INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)INFO:tensorflow:global_step/sec: 210.739INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)INFO:tensorflow:global_step/sec: 234.237INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)INFO:tensorflow:global_step/sec: 238.1INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)INFO:tensorflow:global_step/sec: 237.934INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)INFO:tensorflow:global_step/sec: 220.687INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)INFO:tensorflow:global_step/sec: 232.702INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt.INFO:tensorflow:Loss for final step: 23228.568.
W końcu szacujesz wydajność modelu na zbiorze testowym
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Wynik 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}
Utrata modelu to 1650. Jest to wskaźnik do pokonania w następnej sekcji

Ulepsz model: Termin interakcji
W pierwszej części samouczka zauważyłeś interesującą zależność między zmiennymi. Różne techniki wizualizacji ujawniły, że INDUS i NOS są ze sobą powiązane i zwiększają wpływ na cenę. Nie tylko interakcja między INDUS i NOS wpływa na cenę, ale także ten efekt jest silniejszy, gdy wchodzi w interakcję z DIS.
Nadszedł czas, aby uogólnić ten pomysł i sprawdzić, czy można ulepszyć model przewidywany w modelu.
Musisz dodać dwie nowe kolumny do każdego zestawu danych: pociąg + test. W tym celu tworzysz jedną funkcję do obliczania terminu interakcji, a drugą do obliczania terminu potrójnej interakcji. Każda funkcja tworzy jedną kolumnę. Po utworzeniu nowych zmiennych można połączyć je z zestawem danych szkoleniowych i przetestować zestaw danych.
Przede wszystkim musisz utworzyć nową zmienną dla interakcji między INDUS i NOX.
Poniższa funkcja zwraca dwie ramki danych, train i test, z interakcją między var_1 i var_2, w twoim przypadku INDUS i NOX.
def interaction_term(var_1, var_2, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]test = t_test.rename(name)return train, test
Przechowujesz dwie nowe kolumny
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Po drugie, tworzysz drugą funkcję do obliczania potrójnego składnika interakcji.
def triple_interaction_term(var_1, var_2,var_3, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]test = t_test.rename(name)return train, testinteration_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Teraz, gdy masz już wszystkie potrzebne kolumny, możesz dodać je do trenowania i testowania zestawu danych. Nazwij te dwie nowe ramki danych:

df_train_new
df_test_new

df_train_new = pd.concat([df_train_scale,interation_ind_ns_train,interation_ind_ns_dis_train],axis=1, join='inner')df_test_new = pd.concat([df_test_scale,interation_ind_ns_test,interation_ind_ns_dis_test],axis=1, join='inner')df_train_new.head(5)
Wynik 

To jest to; możesz oszacować nowy model za pomocą warunków interakcji i sprawdzić, jakie są wskaźniki skuteczności.
CONTI_FEATURES_NEW = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS']### Define categorical listcontinuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]model = tf.estimator.LinearRegressor(model_dir="train_Boston_1",feature_columns= categorical_features + continuous_features_new)
Wynik 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
KOD
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']LABEL= 'PRICE'def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)
 
model.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Wynik 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train_Boston_1/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 124.844INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)INFO:tensorflow:global_step/sec: 182.704INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)INFO:tensorflow:global_step/sec: 208.189INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)INFO:tensorflow:global_step/sec: 213.855INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)INFO:tensorflow:global_step/sec: 209.758INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)INFO:tensorflow:global_step/sec: 196.618INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)INFO:tensorflow:global_step/sec: 196.472INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)INFO:tensorflow:global_step/sec: 172.82INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)INFO:tensorflow:global_step/sec: 168.916INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt.INFO:tensorflow:Loss for final step: 19598.387.
 
model.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Wynik 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}
Nowa strata to 1515. Wystarczy dodać dwie nowe zmienne, aby zmniejszyć stratę. Oznacza to, że możesz dokonać lepszej prognozy niż w przypadku modelu porównawczego.