Regresja liniowa z TensorFlow (przykłady)

Spisie treści:

Anonim

Co to jest regresja liniowa?

Regresja liniowa to podejście stosowane w statystyce do modelowania relacji między dwiema zmiennymi. To modelowanie jest wykonywane między odpowiedzią skalarną a jedną lub większą liczbą zmiennych objaśniających. Zależność z jedną zmienną objaśniającą nazywa się prostą regresją liniową, a dla więcej niż jednej zmiennej objaśniającej - wielokrotną regresją liniową.

TensorFlow zapewnia narzędzia do pełnej kontroli nad obliczeniami. Odbywa się to za pomocą niskopoziomowego interfejsu API. Ponadto TensorFlow jest wyposażony w szeroką gamę interfejsów API do wykonywania wielu algorytmów uczenia maszynowego. To jest interfejs API wysokiego poziomu. TensorFlow nazywa je estymatorami

  • Niskopoziomowe API: Zbuduj architekturę, optymalizuj model od podstaw. Dla początkującego jest to skomplikowane
  • Interfejs API wysokiego poziomu: zdefiniuj algorytm. Jest łatwiejszy w obsłudze. TensorFlow zapewnia estymator wywołań zestawu narzędzi do konstruowania, szkolenia, oceny i prognozowania.

W tym samouczku będziesz używać tylko estymatorów . Obliczenia są szybsze i łatwiejsze do wykonania. W pierwszej części samouczka wyjaśniono, jak używać optymalizatora spadku gradientu do trenowania regresji liniowej w TensorFlow. W drugiej części użyjesz zbioru danych Boston do przewidywania ceny domu za pomocą estymatora TensorFlow.

Pobierz Boston DataSet

Z tego samouczka TensorFlow Regression dowiesz się:

  • Co to jest regresja liniowa?
  • Jak wytrenować model regresji liniowej
  • Jak wytrenować regresję liniową za pomocą TensorFlow
  • Pandy
  • Odrętwiałe rozwiązanie
  • Rozwiązanie Tensorflow

Jak wytrenować model regresji liniowej

Zanim zaczniemy trenować model, przyjrzyjmy się, czym jest regresja liniowa.

Wyobraź sobie, że masz dwie zmienne, x i y, a Twoim zadaniem jest przewidzieć wartość znajomości wartości. Jeśli wykreślisz dane, zobaczysz dodatnią zależność między zmienną niezależną x a zmienną zależną y.

Możesz zauważyć, że jeśli x = 1, y będzie w przybliżeniu równe 6, a jeśli x = 2, y będzie wynosić około 8,5.

Nie jest to metoda bardzo dokładna i podatna na błędy, zwłaszcza w przypadku zbioru danych zawierającego setki tysięcy punktów.

Regresja liniowa jest oceniana za pomocą równania. Zmienna y jest wyjaśniona przez jedną lub wiele zmiennych towarzyszących. W twoim przykładzie jest tylko jedna zmienna zależna. Jeśli musisz napisać to równanie, będzie to:

Z:

  • jest wagą związaną z x
  • jest resztą lub błędem modelu. Obejmuje to, czego model nie może nauczyć się z danych

Wyobraź sobie, że dopasowujesz model i znajdujesz następujące rozwiązanie:

  • = 3,8
  • = 2,78

Możesz podstawić te liczby w równaniu i stanie się:

y = 3,8 + 2,78x

Masz teraz lepszy sposób na znalezienie wartości y. Oznacza to, że możesz zastąpić x dowolną wartością, którą chcesz przewidzieć y. Na poniższym obrazku zamieniamy x w równaniu na wszystkie wartości ze zbioru danych i wykreślamy wynik.

Czerwona linia przedstawia dopasowaną wartość, czyli wartości y dla każdej wartości x. Nie musisz widzieć wartości x, aby przewidzieć y, dla każdego x jest taki, który należy do czerwonej linii. Możesz także przewidzieć wartości x większe niż 2!

Jeśli chcesz rozszerzyć regresję liniową na więcej zmiennych towarzyszących, możesz dodać więcej zmiennych do modelu. Różnica między tradycyjną analizą a regresją liniową polega na tym, że regresja liniowa sprawdza, jak y zareaguje na każdą zmienną x wziętą niezależnie.

Zobaczmy przykład. Wyobraź sobie, że chcesz przewidzieć sprzedaż w lodziarni. Zbiór danych zawiera różne informacje, takie jak pogoda (np. Deszczowa, słoneczna, pochmurna), informacje o klientach (np. Wynagrodzenie, płeć, stan cywilny).

Tradycyjna analiza spróbuje przewidzieć sprzedaż, powiedzmy obliczając średnią dla każdej zmiennej i spróbuje oszacować sprzedaż dla różnych scenariuszy. Doprowadzi to do złych prognoz i ograniczy analizę do wybranego scenariusza.

Jeśli używasz regresji liniowej, możesz napisać to równanie:

Algorytm znajdzie najlepsze rozwiązanie dla wag; oznacza to, że spróbuje zminimalizować koszt (różnica między dopasowaną linią a punktami danych).

Jak działa algorytm

Algorytm wybierze losową liczbę dla każdego wartość x, aby uzyskać przewidywaną wartość y. Jeśli zbiór danych zawiera 100 obserwacji, algorytm oblicza 100 przewidywanych wartości.

Możemy obliczyć błąd zanotowany w modelu, który jest różnicą między wartością przewidywaną a wartością rzeczywistą. Dodatni błąd oznacza, że ​​model nie docenia prognozy y, a błąd ujemny oznacza, że ​​model przeszacowuje przewidywanie y.

Twoim celem jest zminimalizowanie kwadratu błędu. Algorytm oblicza średnią błędu kwadratowego. Ten krok nazywa się minimalizacją błędu. W przypadku regresji liniowej jest to średni błąd kwadratowy , zwany również MSE. Matematycznie jest to:

Gdzie:

  • odnosi się do wartości przewidywanej
  • y to rzeczywiste wartości
  • m to liczba obserwacji

Zauważ, że jest matematycznym zapisem średniej.

Celem jest znalezienie najlepszych, które zminimalizują MSE

Jeśli średni błąd jest duży, oznacza to, że model działa słabo, a wagi nie są odpowiednio dobrane. Aby skorygować wagi, musisz użyć optymalizatora. Tradycyjny optymalizator nosi nazwę Gradient Descent .

Zejście gradientowe przyjmuje pochodną i zmniejsza lub zwiększa wagę. Jeśli pochodna jest dodatnia, waga jest zmniejszana. Jeśli pochodna jest ujemna, waga wzrasta. Model zaktualizuje wagi i ponownie obliczy błąd. Ten proces jest powtarzany, dopóki błąd się nie zmieni. Każdy proces nazywany jest iteracją . Poza tym gradienty są mnożone przez współczynnik uczenia się. Wskazuje prędkość uczenia się.

Jeśli współczynnik uczenia się jest zbyt mały, zbieżność algorytmu zajmie bardzo dużo czasu (tj. Wymaga wielu iteracji). Jeśli współczynnik uczenia się jest zbyt wysoki, algorytm może nigdy nie osiągnąć zbieżności.

Na powyższym obrazku widać, że model powtarza ten proces około 20 razy, zanim znajdzie stabilną wartość dla wag, osiągając najniższy błąd.

Zwróć uwagę , że błąd nie jest równy zero, ale stabilizuje się wokół 5. Oznacza to, że model popełnia typowy błąd 5. Jeśli chcesz zmniejszyć błąd, musisz dodać więcej informacji do modelu, takich jak więcej zmiennych lub użyć różne estymatory.

Pamiętasz pierwsze równanie

Ostateczne wagi to 3,8 i 2,78. Poniższy film pokazuje, jak zejście gradientowe optymalizuje funkcję utraty w celu znalezienia tych wag

Jak wytrenować regresję liniową za pomocą TensorFlow

Teraz, gdy masz lepsze zrozumienie tego, co dzieje się za maską, możesz użyć interfejsu API estymatora udostępnianego przez TensorFlow do trenowania pierwszej regresji liniowej za pomocą TensorFlow.

Będziesz używać zestawu danych Boston, który zawiera następujące zmienne

crim wskaźnik przestępczości na mieszkańca według miast
zn odsetek terenów mieszkalnych przeznaczonych pod działki powyżej 25 000 stóp kwadratowych.
indus udział akrów niedetalicznych przypadających na miasto.
nox stężenie tlenków azotu
rm średnia liczba izb w mieszkaniu
wiek odsetek lokali okupowanych przez właścicieli wybudowanych 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 miast
medv Mediana wartości domów zajmowanych przez właścicieli w tysiącach dolarów

Utworzysz trzy różne zbiory danych:

zbiór danych cel kształt
Trening Wytrenuj model i uzyskaj ciężary 400, 10
Ocena Oceń wydajność modelu na niewidocznych danych 100, 10
Przepowiadać, wywróżyć Użyj modelu, aby przewidzieć wartość domu dla nowych danych 6, 10

Celem jest wykorzystanie cech zbioru danych do przewidywania wartości domu.

W drugiej części samouczka dowiesz się, jak używać TensorFlow z trzema różnymi sposobami importowania danych:

  • Z pandami
  • Z Numpy
  • Tylko TF

Zwróć uwagę, że wszystkie opcje dają takie same wyniki.

Dowiesz się, jak używać interfejsu API wysokiego poziomu do budowania, trenowania oceny modelu regresji liniowej TensorFlow. Jeśli korzystałeś z niskopoziomowego interfejsu API, musiałeś ręcznie zdefiniować:

  • Funkcja strat
  • Optymalizuj: zejście gradientowe
  • Mnożenie macierzy
  • Wykres i tensor

Jest to żmudne i bardziej skomplikowane dla początkujących.

Pandy

Aby wytrenować model, musisz zaimportować niezbędne biblioteki.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Krok 1) Zaimportuj dane za pomocą pandy.

Definiujesz nazwy kolumn i przechowujesz je w COLUMNS. Możesz użyć pd.read_csv (), aby zaimportować dane.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]

training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

Możesz wydrukować kształt danych.

print(training_set.shape, test_set.shape, prediction_set.shape)

Wynik

(400, 10) (100, 10) (6, 10)

Zwróć uwagę, że etykieta, czyli Twój y, jest zawarta w zbiorze danych. Musisz więc zdefiniować dwie inne listy. Jeden zawierający tylko funkcje, a drugi tylko z nazwą etykiety. Te dwie listy powiedzą Twojemu estymatorowi, jakie są funkcje w zbiorze danych i jaka nazwa kolumny jest etykietą

Odbywa się to za pomocą poniższego kodu.

FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv"

Krok 2) Konwertuj dane

Musisz przekonwertować zmienne numeryczne w odpowiednim formacie. Tensorflow udostępnia metodę konwersji zmiennych ciągłych: tf.feature_column.numeric_column ().

W poprzednim kroku zdefiniujesz na liście element, który chcesz uwzględnić w modelu. Teraz możesz użyć tej listy, aby przekonwertować je na dane liczbowe. Jeśli chcesz wykluczyć funkcje w swoim modelu, możesz upuścić jedną lub więcej zmiennych z listy FUNKCJE przed utworzeniem elementów feature_cols

Zwróć uwagę, że będziesz używać funkcji rozumienia list w języku Python z listą FUNKCJE, aby utworzyć nową listę o nazwie feature_cols. Pomaga to uniknąć dziewięciokrotnego wpisania tf.feature_column.numeric_column (). Zrozumienie list to szybszy i bardziej przejrzysty sposób tworzenia nowych list

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Krok 3) Zdefiniuj estymator

Na tym etapie musisz zdefiniować estymator. Tensorflow udostępnia obecnie 6 gotowych estymatorów, w tym 3 dla zadania klasyfikacyjnego i 3 dla zadania regresji TensorFlow:

  • Regresor
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Klasyfikator
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

W tym samouczku użyjesz regresora liniowego. Aby uzyskać dostęp do tej funkcji, musisz użyć tf.estimator.

Funkcja potrzebuje dwóch argumentów:

  • kolumny_funkcji: zawiera zmienne do uwzględnienia w modelu
  • model_dir: ścieżka do przechowywania wykresu, zapisywania parametrów modelu itp

Tensorflow automatycznie utworzy plik o nazwie train w Twoim katalogu roboczym. Musisz użyć tej ścieżki, aby uzyskać dostęp do Tensorboard, jak pokazano na poniższym przykładzie regresji TensorFlow.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")

Wynik

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train', '_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}

Najtrudniejszą częścią TensorFlow jest sposób zasilania modelu. Tensorflow jest przeznaczony do pracy z obliczeniami równoległymi i bardzo dużym zbiorem danych. Ze względu na ograniczenia zasobów maszynowych nie jest możliwe zasilanie modelu wszystkimi danymi naraz. W tym celu za każdym razem musisz dostarczać porcję danych. Zwróć uwagę, że mówimy o ogromnym zbiorze danych z milionami lub więcej rekordów. Jeśli nie dodasz partii, skończy się błąd pamięci.

Na przykład, jeśli twoje dane zawierają 100 obserwacji i zdefiniujesz rozmiar partii 10, oznacza to, że model będzie widział 10 obserwacji dla każdej iteracji (10 * 10).

Kiedy model zobaczy wszystkie dane, kończy jedną epokę . Epoka określa, ile razy model ma widzieć dane. Lepiej jest ustawić ten krok na none i pozwolić modelowi na wykonanie iteracji przez określoną liczbę razy.

Drugą informacją do dodania jest wymieszanie danych przed każdą iteracją. Podczas szkolenia ważne jest przetasowanie danych, aby model nie nauczył się określonego wzorca zbioru danych. Jeśli model pozna szczegóły podstawowego wzorca danych, będzie miał trudności z uogólnieniem prognozy dla niewidocznych danych. Nazywa się to nadmiernym dopasowaniem . Model działa dobrze na danych uczących, ale nie może poprawnie przewidywać niewidocznych danych.

Dzięki TensorFlow te dwa kroki są łatwe do wykonania. Kiedy dane trafiają do potoku, wie, ile obserwacji potrzebuje (partia) i czy musi je przetasować.

Aby poinstruować Tensorflow, jak zasilać model, możesz użyć pandas_input_fn. Ten obiekt potrzebuje 5 parametrów:

  • x: dane funkcji
  • y: dane etykiety
  • batch_size: partia. Domyślnie 128
  • num_epoch: liczba epok, domyślnie 1
  • shuffle: pomieszaj dane lub nie. Domyślnie brak

Musisz wielokrotnie podawać model, więc definiujesz funkcję, aby powtórzyć ten proces. cała ta funkcja get_input_fn.

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)

Zwykłą metodą oceny wydajności modelu jest:

  • Wytrenuj model
  • Oceń model w innym zbiorze danych
  • Przewidzieć

Estymator Tensorflow zapewnia trzy różne funkcje ułatwiające wykonanie tych trzech kroków.

Krok 4) : Wytrenuj model

Możesz użyć pociągu estymatora do oceny modelu. Estymator pociągu potrzebuje parametru input_fn i pewnej liczby kroków. Możesz użyć funkcji, którą utworzyłeś powyżej, aby zasilić model. Następnie nakazujesz modelowi wykonanie iteracji 1000 razy. Zwróć uwagę, że nie określasz liczby epok, pozwalasz modelowi wykonać iterację 1000 razy. Jeśli ustawisz liczbę epok na 1, model będzie iterował 4 razy: w zbiorze uczącym jest 400 rekordów, a rozmiar wsadu to 128

  1. 128 rzędów
  2. 128 rzędów
  3. 128 rzędów
  4. 16 rzędów

Dlatego łatwiej jest ustawić liczbę epok na brak i zdefiniować liczbę iteracji, jak pokazano w poniższym przykładzie klasyfikacji TensorFlow.

estimator.train(input_fn=get_input_fn(training_set,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/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.

Możesz sprawdzić, czy Tensorboard wykona następujące polecenie:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

Krok 5) Oceń swój model

Możesz ocenić dopasowanie swojego modelu do zestawu testowego za pomocą poniższego kodu:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))

Wynik

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Możesz wydrukować stratę za pomocą poniższego kodu:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))

Wynik

Loss: 3215.895996

Model ma stratę 3215. Możesz sprawdzić statystyki podsumowujące, aby zorientować się, jak duży jest błąd.

training_set['medv'].describe()

Wynik

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

Z powyższej sumarycznej statystyki wiesz, że średnia cena domu to 22 tys. Przy cenie minimalnej 9 tys., A maksymalnej 50 tys. Model popełnia typowy błąd 3k dolarów.

Krok 6) Dokonaj prognozy

Wreszcie, możesz użyć estymatora TensorFlow Predict do oszacowania wartości 6 domów w Bostonie.

y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False))

Aby wydrukować szacunkowe wartości, możesz użyć tego kodu:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Wynik

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Model prognozuje następujące wartości:

Dom

Prognoza

1

32,29

2

18,96

3

27,27

4

29.29

5

16.43

7

21.46

Zauważ, że nie znamy prawdziwej wartości. W samouczku głębokiego uczenia się spróbujesz pokonać model liniowy

Odrętwiałe rozwiązanie

W tej sekcji wyjaśniono, jak wytrenować model przy użyciu estymatora numpy do dostarczania danych. Metoda jest taka sama, z wyjątkiem tego, że użyjesz estymatora numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). wartości

test_set_n = pd.read_csv ("E: /boston_test.csv"). wartości

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). wartości

Krok 1) Zaimportuj dane

Przede wszystkim musisz odróżnić zmienne funkcji od etykiety. Musisz to zrobić dla danych szkoleniowych i oceny. Szybciej jest zdefiniować funkcję do dzielenia danych.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train

Możesz użyć tej funkcji, aby oddzielić etykietę od funkcji zestawu danych pociągu / oceny

X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)

Musisz wykluczyć ostatnią kolumnę zestawu danych prognozy, ponieważ zawiera ona tylko NaN

x_predict = prediction_set_n[:, :-2]

Potwierdź kształt tablicy. Zauważ, że etykieta nie powinna mieć wymiaru, to znaczy (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Wynik

(400, 9) (400,) (6, 9)

Możesz skonstruować kolumny funkcji w następujący sposób:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Estymator jest zdefiniowany jak poprzednio, poinstruujesz kolumny cech i gdzie zapisać wykres.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Wynik

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train1', '_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}

Możesz użyć estymatora numpy, aby dostarczyć dane do modelu, a następnie wytrenować model. Zauważ, że wcześniej zdefiniowaliśmy funkcję input_fn, aby ułatwić czytelność.

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_train},y=y_train,batch_size=128,shuffle=False,num_epochs=None)estimator.train(input_fn = train_input,steps=5000)

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 train1/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.INFO:tensorflow:Loss for final step: 5925.985.Out[23]:

Powielasz ten sam krok z innym estymatorem, aby ocenić swój model

eval_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_test},y=y_test,shuffle=False,batch_size=128,num_epochs=1)estimator.evaluate(eval_input,steps=None)

Wynik

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Na koniec możesz obliczyć prognozę. Powinien być podobny do pandy.

test_input = tf.estimator.inputs.numpy_input_fn(x={"x": x_predict},batch_size=128,num_epochs=1,shuffle=False)y = estimator.predict(test_input)predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Wynik

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Rozwiązanie Tensorflow

Ostatnia sekcja jest poświęcona rozwiązaniu TensorFlow. Ta metoda jest nieco bardziej skomplikowana niż druga.

Zauważ, że jeśli używasz notatnika Jupyter, musisz ponownie uruchomić i wyczyścić jądro, aby uruchomić tę sesję.

TensorFlow stworzył świetne narzędzie do przekazywania danych do potoku. W tej sekcji samodzielnie zbudujesz funkcję input_fn.

Krok 1) Określ ścieżkę i format danych

Przede wszystkim deklarujesz dwie zmienne ze ścieżką do pliku csv. Zauważ, że masz dwa pliki, jeden dla zestawu uczącego i jeden dla zestawu testowego.

import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"

Następnie musisz zdefiniować kolumny, których chcesz użyć, z pliku csv. Wykorzystamy wszystko. Następnie musisz zadeklarować typ zmiennej, którą to jest.

Zmienna zmiennoprzecinkowa jest zdefiniowana przez [0]

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]

Krok 2) Zdefiniuj funkcję input_fn

Funkcję można podzielić na trzy części:

  1. Zaimportuj dane
  2. Utwórz iterator
  3. Zużyj dane

Poniżej znajduje się ogólny kod definiujący funkcję. Kod zostanie wyjaśniony później

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def parse_csv(value):columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)features = dict(zip(COLUMNS, columns))#labels = features.pop('median_house_value')labels = features.pop('medv')return features, labels# Extract lines from input files using theDataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file.skip(1) # Skip header row.map(parse_csv))dataset = dataset.repeat(num_epoch)dataset = dataset.batch(batch_size)# Step 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Importuj dane **

W przypadku pliku csv metoda zestawu danych odczytuje jednocześnie jeden wiersz. Aby zbudować zbiór danych, musisz użyć obiektu TextLineDataset. Twój zestaw danych ma nagłówek, więc musisz użyć skip (1), aby pominąć pierwszą linię. W tym momencie odczytujesz tylko dane i wykluczasz nagłówek w potoku. Aby zasilić model, musisz oddzielić elementy od etykiety. Metodą zastosowaną do zastosowania dowolnej transformacji do danych jest map.

Ta metoda wywołuje funkcję, którą utworzysz, aby poinstruować, jak przekształcić dane, w skrócie, musisz przekazać dane w obiekcie TextLineDataset, wykluczyć nagłówek i zastosować transformację, która jest instruowana przez funkcję.

  • tf.data.TextLineDataset (data_file): ta linia odczytuje plik csv
  • .skip (1): pomiń nagłówek
  • .map (parse_csv)): parsuj rekordy do tensorów Musisz zdefiniować funkcję, aby instruować obiekt mapy. Możesz wywołać tę funkcję parse_csv.

Ta funkcja analizuje plik csv metodą tf.decode_csv i deklaruje funkcje oraz etykietę. Funkcje można zadeklarować jako słownik lub krotkę. Używasz metody słownikowej, ponieważ jest to wygodniejsze. Objaśnienie kodu

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): metoda decode_csv wykorzystuje dane wyjściowe zestawu TextLineDataset do odczytu pliku csv. record_defaults instruuje TensorFlow o typie kolumn.
  • dict (zip (_CSV_COLUMNS, columns)): Wypełnij słownik wszystkimi kolumnami wyodrębnionymi podczas tego przetwarzania danych
  • features.pop ('median_house_value'): Wyklucz zmienną docelową ze zmiennej funkcji i utwórz zmienną etykiety

Zestaw danych potrzebuje dalszych elementów, aby iteracyjnie zasilać tensory. Rzeczywiście, musisz dodać powtarzanie metody, aby umożliwić zestawowi danych nieprzerwane zasilanie modelu. Jeśli nie dodasz metody, model przeprowadzi iterację tylko raz, a następnie zgłosi błąd, ponieważ w potoku nie są już przekazywane żadne dane.

Następnie możesz kontrolować wielkość partii za pomocą metody partii. Oznacza to, że informujesz zestaw danych, ile danych chcesz przekazać w potoku dla każdej iteracji. Jeśli ustawisz duży rozmiar partii, model będzie powolny.

Krok 3) Utwórz iterator

Teraz jesteś gotowy na drugi krok: utwórz iterator, aby zwrócić elementy w zestawie danych.

Najprostszym sposobem stworzenia operatora jest użycie metody make_one_shot_iterator.

Następnie możesz utworzyć elementy i etykiety z iteratora.

Krok 4) Zbierz dane

Możesz sprawdzić, co się dzieje z funkcją input_fn. Musisz wywołać tę funkcję w sesji, aby wykorzystać dane. Próbujesz z wielkością partii równą 1.

Zauważ, że wypisuje funkcje w słowniku i etykietę jako tablicę.

Pokaże pierwszą linię pliku csv. Możesz spróbować uruchomić ten kod wiele razy z innym rozmiarem partii.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)with tf.Session() as sess:first_batch = sess.run(next_batch)print(first_batch)

Wynik

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

Krok 4) Zdefiniuj kolumnę funkcji

Musisz zdefiniować kolumny liczbowe w następujący sposób:

X1= tf.feature_column.numeric_column('crim')X2= tf.feature_column.numeric_column('zn')X3= tf.feature_column.numeric_column('indus')X4= tf.feature_column.numeric_column('nox')X5= tf.feature_column.numeric_column('rm')X6= tf.feature_column.numeric_column('age')X7= tf.feature_column.numeric_column('dis')X8= tf.feature_column.numeric_column('tax')X9= tf.feature_column.numeric_column('ptratio')

Zwróć uwagę, że musisz połączyć wszystkie zmienne w zasobniku

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Krok 5) Zbuduj model

Model można uczyć za pomocą estymatora LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Wynik

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_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}

Musisz użyć funkcji lambda, aby umożliwić zapisanie argumentu w funkcji inpu_fn. Jeśli nie używasz funkcji lambda, nie możesz wytrenować modelu.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

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 train3/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.Out[8]:

Możesz ocenić dopasowanie swojego modelu do zestawu testowego za pomocą poniższego kodu:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))for key in results:print(" {}, was: {}".format(key, results[key]))

Wynik

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

Ostatnim krokiem jest przewidywanie wartości na podstawie wartości macierzy cech. Możesz napisać słownik z wartościami, które chcesz przewidzieć. Twój model ma 9 funkcji, więc musisz podać wartość dla każdej z nich. Model zapewni prognozę dla każdego z nich.

W poniższym kodzie zapisałeś wartości każdej funkcji zawartej w pliku csv df_predict.

Musisz napisać nową funkcję input_fn, ponieważ w zbiorze danych nie ma etykiety. Możesz użyć interfejsu API from_tensor z zestawu danych.

prediction_input = {'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],'zn': [75.0,0.0,25.0,33.0,0.0,0.0],'indus': [2.95,18.10,5.13,2.18,18.10,9.90],'nox': [0.428,0.713,0.453,0.472,0.700,0.544],'rm': [7.024,6.297,6.762,7.236,5.390,5.782],'age': [15.8,91.8,43.4,41.1,98.9,71.7],'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],'tax': [252,666,284,222,666,304],'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]}def test_input_fn():dataset = tf.data.Dataset.from_tensors(prediction_input)return dataset# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)

Na koniec drukujesz prognozy.

for pred in enumerate(pred_results):print(pred)

Wynik

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.(0, {'predictions': array([32.297546], dtype=float32)})(1, {'predictions': array([18.96125], dtype=float32)})(2, {'predictions': array([27.270979], dtype=float32)})(3, {'predictions': array([29.299236], dtype=float32)})(4, {'predictions': array([16.436684], dtype=float32)})(5, {'predictions': array([21.460876], dtype=float32)})INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

Podsumowanie

Aby wytrenować model, musisz:

  • Zdefiniuj cechy: Zmienne niezależne: X
  • Zdefiniuj etykietę: Zmienna zależna: y
  • Skonstruuj pociąg / zestaw testowy
  • Określ wagę początkową
  • Zdefiniuj funkcję straty: MSE
  • Zoptymalizuj model: Zejście gradientowe
  • Definiować:
    • Szybkość uczenia się
    • Liczba epok
    • Wielkość partii

W tym samouczku nauczyłeś się, jak używać interfejsu API wysokiego poziomu do estymatora TensorFlow regresji liniowej. Musisz zdefiniować:

  1. Kolumny funkcji. Jeśli ciągłe: tf.feature_column.numeric_column (). Listę można wypełnić za pomocą funkcji rozumienia list w języku Python
  2. Estymator: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Funkcja do importu danych, rozmiaru partii i epoki: input_fn ()

Następnie możesz trenować, oceniać i prognozować za pomocą train (), szacować () i przewidywać ()