Samouczek dotyczący regresji liniowej z TensorFlow [Przykłady]
Evelyn Clarke
Co to jest regresja liniowa?
regresji liniowej to podejście stosowane w statystyce do modelowania relacji między dwiema zmiennymi. Modelowanie to odbywa się pomię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 w przypadku więcej niż jednej zmiennej objaśniającej nazywa się ją wielokrotną regresją liniową.
TensorFlow zapewnia narzędzia umożliwiające pełną kontrolę nad obliczeniami. Odbywa się to za pomocą niskopoziomowego interfejsu API. Co więcej, TensorFlow jest wyposażony w szeroką gamę interfejsów API umożliwiających wykonywanie wielu operacji uczenie maszynowe algorytmy. To jest API wysokiego poziomu. TensorFlow nazywa je estymatorami
- API niskiego poziomu: Zbuduj architekturę, optymalizację modelu od podstaw. To skomplikowane dla początkującego
- Interfejs API wysokiego poziomu: Zdefiniuj algorytm. Jest on przyjazny dla użytkownika. TensorFlow udostępnia zestaw narzędzi o nazwie taksator konstruować, szkolić, oceniać i przewidywać.
W tym samouczku użyjesz tylko estymatory. Obliczenia są szybsze i łatwiejsze do wdrożenia. W pierwszej części samouczka wyjaśniono, jak używać optymalizatora opadania gradientu do uczenia regresji liniowej w TensorFlow. W drugiej części wykorzystasz zbiór danych Bostonu do przewidzenia ceny domu za pomocą estymatora 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 przewidzenie wartości, znając wartość . Jeśli narysujesz dane, możesz zobaczyć dodatnią zależność między zmienną niezależną x i zmienną zależną y.
Możesz zaobserwować, ż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.
Regresję liniową ocenia się za pomocą równania. Zmienna y jest wyjaśniona przez jedną lub wiele współzmiennych. W twoim przykładzie istnieje tylko jedna zmienna zależna. Jeśli musisz napisać to równanie, będzie to:
Z:
jest stronniczość. tj. jeśli x=0, y=
jest wagą związaną z x
jest resztą lub błędem modelu. Obejmuje to, czego model nie może się nauczyć z danych
Wyobraź sobie, że dopasowujesz model i znajdujesz następujące rozwiązanie:
- = 3.8
- = 2.78
Możesz podstawić te liczby do równania i otrzymasz:
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 zastąpiliśmy x w równaniu wszystkimi wartościami ze zbioru danych i wykreśliliśmy 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 istnieje 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 współzmiennych, możesz to zrobić, dodając 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. Zestaw danych zawiera różne informacje, takie jak pogoda (np. deszczowo, słonecznie, pochmurno), informacje o klientach (np. pensja, płeć, stan cywilny).
Tradycyjna analiza będzie próbowała przewidzieć sprzedaż, powiedzmy obliczając średnią dla każdej zmiennej i próbując oszacować sprzedaż dla różnych scenariuszy. Doprowadzi to do błędnych przewidywań i ograniczy analizę do wybranego scenariusza.
Jeśli użyjesz regresji liniowej, możesz zapisać to równanie:
Algorytm znajdzie najlepsze rozwiązanie dla wag; oznacza to, że spróbuje zminimalizować koszt (różnicę między dopasowaną linią a punktami danych).
Jak działa algorytm
Algorytm wybierze dla każdego losową liczbę 
i 
i zamień wartość x, aby uzyskać przewidywaną wartość y. Jeśli zbiór danych zawiera 100 obserwacji, algorytm oblicza 100 przewidywanych wartości.
Zauważyliśmy, że możemy obliczyć błąd 
modelu, czyli różnicę pomiędzy wartością przewidywaną a wartością rzeczywistą. Dodatni błąd oznacza, że model zaniża przewidywanie 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. Dla regresji liniowej jest Średni błąd kwadratowy, zwany także MSE. Matematycznie jest to:
Gdzie:
czy ciężary tak 
odnosi się do przewidywanej wartości- y to wartości rzeczywiste
- m to liczba obserwacji
odnosi się do przewidywanej wartościNależy pamiętać, że 
oznacza, że wykorzystuje transpozycję macierzy. The 
jest matematycznym zapisem średniej.
Celem jest znalezienie najlepszych 
które minimalizują MSE
Jeśli średni błąd jest duży, oznacza to, że model działa słabo, a wagi są niewłaściwie dobrane. Aby skorygować wagi, należy użyć optymalizatora. Tradycyjny optymalizator nazywa się Gradientowe zejście.
Zejście gradientowe uwzględnia 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. Proces ten powtarza się, aż błąd przestanie się zmieniać. Każdy proces nazywa się iteracja. Poza tym gradienty są mnożone przez szybkość uczenia się. Wskazuje szybkość uczenia się.
Jeśli szybkość uczenia się jest zbyt mała, osiągnięcie zbieżności algorytmu zajmie bardzo dużo czasu (tj. wymaga wielu iteracji). Jeśli szybkość uczenia się jest zbyt wysoka, algorytm może nigdy nie osiągnąć zbieżności.
Jak widać na powyższym obrazku, model powtarza ten proces około 20 razy, aby znaleźć stabilną wartość wag, osiągając w ten sposób najniższy błąd.
Należy pamiętać, że, błąd nie jest równy zero, ale stabilizuje się w okolicach 5. Oznacza to, że model popełnia typowy błąd wynoszący 5. Jeśli chcesz zmniejszyć błąd, musisz dodać do modelu więcej informacji, np. więcej zmiennych lub zastosować inne estymatory .
Pamiętasz pierwsze równanie
Ostateczne wagi to 3.8 i 2.78. Poniższy film pokazuje, jak opadanie gradientu optymalizuje funkcję straty, aby znaleźć te wagi
Jak wytrenować regresję liniową za pomocą TensorFlow
Teraz, gdy lepiej rozumiesz, co dzieje się za maską, możesz skorzystać z interfejsu API estymatora dostarczonego przez TensorFlow, aby wytrenować pierwszą regresję liniową za pomocą TensorFlow.
Użyjesz zestawu danych Boston Dataset, który zawiera następujące zmienne
| kryminalny | wskaźnik przestępczości na mieszkańca według miasta |
|---|---|
| zn | część gruntów mieszkalnych przeznaczonych na działki o powierzchni powyżej 25,000 XNUMX stóp kwadratowych. |
| indus | odsetek powierzchni użytków niehandlowych przypadających na miasto. |
| nox | stężenie tlenków azotu |
| rm | średnia liczba pokoi w mieszkaniu |
| wiek | odsetek mieszkań własnościowych wybudowanych przed 1940 rokiem |
| dis | odległości ważone do pięciu bostońskich centrów zatrudnienia |
| podatek | pełnowartościowa stawka podatku od nieruchomości na 10,000 XNUMX dolarów |
| ptratio | stosunek liczby uczniów do nauczycieli według miasta |
| med | Średnia wartość domów zamieszkałych przez właścicieli w tysiącach dolarów |
Utworzysz trzy różne zbiory danych:
| zestaw danych | cel | kształt |
|---|---|---|
| Szkolenia | Wytrenuj model i uzyskaj ciężary | 400, 10 |
| Ocena | Oceń wydajność modelu na niewidocznych danych | 100, 10 |
| Przewiduj | Użyj modelu, aby przewidzieć wartość domu na podstawie 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 na trzy różne sposoby importowania danych:
- Z Pandami
- Wraz z Odrętwiały
- Tylko TF
Pamiętaj, że wszystkie opcje zapewnić takie same wyniki.
Dowiesz się, jak używać API wysokiego poziomu do budowania, trenowania i oceny modelu regresji liniowej TensorFlow. Jeśli korzystałeś z interfejsu API niskiego poziomu, musiałeś ręcznie zdefiniować:
- Funkcja utraty
- Optymalizuj: opadanie gradientowe
- Mnożenie macierzy
- Wykres i tensor
Jest to żmudne i bardziej skomplikowane dla początkującego.
Pandy
Aby wytrenować model, należy zaimportować niezbędne biblioteki.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Krok 1) Zaimportuj dane za pomocą panda.
Definiujesz nazwy kolumn i przechowujesz je w COLUMNS. Aby zaimportować dane, możesz użyć pd.read_csv().
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]
Training_set = pd.read_csv(“E:/boston_train.csv”, skipinitialspace=True,skiprows=1, name=COLUMNS)
test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, nazwy=KOLUMNY)
przewidywanie_zestaw = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, nazwy=KOLUMNY)
Można wydrukować kształt danych.
print(training_set.shape, test_set.shape, prediction_set.shape)
Wydajność
(400, 10) (100, 10) (6, 10)
Pamiętaj, że etykieta, czyli Twoje y, jest zawarta w zbiorze danych. Musisz więc zdefiniować dwie inne listy. Jedna zawierająca tylko funkcje i jedna zawierająca wyłącznie nazwę etykiety. Te dwie listy powiedzą Twojemu estymatorowi, jakie są cechy zbioru danych i jaka nazwa kolumny jest etykietą
Robi się to za pomocą poniższego kodu.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Krok 2) Konwertuj dane
Należy przekonwertować zmienne numeryczne na odpowiedni format. Tensorflow zapewnia metodę konwersji zmiennej ciągłej: tf.feature_column.numeric_column().
W poprzednim kroku zdefiniowałeś listę funkcji, które chcesz uwzględnić w modelu. Teraz możesz użyć tej listy, aby przekonwertować je na dane liczbowe. Jeśli chcesz wykluczyć funkcje ze swojego modelu, możesz usunąć jedną lub więcej zmiennych z listy FEATURES przed skonstruowaniem funkcji feature_cols
Pamiętaj, że będziesz korzystać Python rozumienie list z listą FEATURES, aby utworzyć nową listę o nazwie feature_cols. Pomaga uniknąć dziewięciokrotnego pisania tf.feature_column.numeric_column(). Rozumienie listy to szybszy i czystszy sposób tworzenia nowych list
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Krok 3) Zdefiniuj estymator
Na tym etapie należy zdefiniować estymator. Tensorflow udostępnia obecnie 6 gotowych estymatorów, w tym 3 do zadania klasyfikacji i 3 do zadania regresji TensorFlow:
- Regresor
- DNNRegresor
- Regresor liniowy
- DNLineaPołączony regresor
- klasyfikować
- Klasyfikator DNN
- Klasyfikator liniowy
- DNLineaCombinedClassifier
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:
- feature_columns: zawiera zmienne, które mają zostać uwzględnione w modelu
- model_dir: ścieżka do przechowywania wykresu, zapisania 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 w poniższym przykładzie regresji TensorFlow.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
Wydajność
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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_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}
Trudną częścią TensorFlow jest sposób zasilania modelu. Tensorflow został zaprojektowany do pracy z obliczeniami równoległymi i bardzo dużym zbiorem danych. Ze względu na ograniczone zasoby maszyny nie jest możliwe zasilenie modelu wszystkimi danymi na raz. W tym celu za każdym razem musisz podać porcję danych. Pamiętaj, że mówimy o ogromnym zbiorze danych zawierającym miliony lub więcej rekordów. Jeśli nie dodasz partii, wystąpi błąd pamięci.
Na przykład, jeśli dane zawierają 100 obserwacji i zdefiniujesz wielkość partii 10, oznacza to, że model będzie widział 10 obserwacji w każdej iteracji (10*10).
Kiedy model zobaczy wszystkie dane, kończy jeden epoka. Epoka określa, ile razy model ma widzieć dane. Lepiej ustawić ten krok na none i pozwolić modelowi wykonać liczbę iteracji.
Drugą informacją, którą należy dodać, jest to, czy chcesz przetasować dane przed każdą iteracją. Podczas treningu ważne jest przetasowanie danych, aby model nie nauczył się określonego wzorca zbioru danych. Jeśli model nauczy się szczegółów podstawowego wzorca danych, będzie miał trudności z uogólnieniem prognozy dla niewidzianych danych. To się nazywa nadmierne dopasowanie. Model działa dobrze na danych uczących, ale nie jest w stanie poprawnie przewidzieć danych niewidocznych.
Dzięki TensorFlow te dwa kroki są łatwe do wykonania. Kiedy dane trafiają do potoku, wie, ile obserwacji potrzebuje (wsadowo) i czy musi przetasować dane.
Aby poinstruować Tensorflow, jak zasilić model, możesz użyć pandas_input_fn. Obiekt ten potrzebuje 5 parametrów:
- x: dane funkcji
- y: dane etykiety
- rozmiar_partia: partia. Domyślnie 128
- num_epoch: Numer epoki, domyślnie 1
- shuffle: Potasuj lub nie dane. Domyślnie Brak
Musisz wielokrotnie zasilać model, więc zdefiniuj funkcję powtarzającą 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)
Typową metodą oceny wydajności modelu jest:
- Trenuj model
- Oceń model w innym zbiorze danych
- Przewidzieć
Estymator Tensorflow zapewnia trzy różne funkcje umożliwiające łatwe przeprowadzenie tych trzech kroków.
Krok 4): Trenuj model
Do oceny modelu można użyć zestawu estymatorów. Estymator pociągu potrzebuje input_fn i pewnej liczby kroków. Możesz użyć funkcji utworzonej powyżej, aby zasilić model. Następnie instruujesz model, aby wykonał 1000 powtórzeń. Zauważ, że nie określasz liczby epok, pozwalasz modelowi wykonać 1000 iteracji. Jeśli ustawisz liczbę epok na 1, model wykona iterację 4 razy: w zestawie treningowym znajduje się 400 rekordów, a wielkość partii wynosi 128
- Wiersze 128
- Wiersze 128
- Wiersze 128
- Wiersze 16
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)
Wydajność
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 = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO: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ć Tensorboard za pomocą następującego polecenia:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Krok 5) Oceń swój model
Możesz ocenić dopasowanie swojego modelu na zestawie testowym, korzystając z poniższego kodu:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Wydajność
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
Stratę możesz wydrukować za pomocą poniższego kodu:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
Wydajność
Loss: 3215.895996
Model wykazuje stratę 3215. Możesz sprawdzić statystyki podsumowujące, aby zorientować się, jak duży jest błąd.
training_set['medv'].describe()
Wydajność
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Z powyższej statystyki zbiorczej wiesz, że średnia cena domu to 22 tys., przy cenie minimalnej 9 tys. i maksymalnej 50 tys. Model popełnia typowy błąd rzędu 3 tys. dolarów.
Krok 6) Dokonaj prognozy
Na koniec możesz użyć prognozy TensorFlow, aby oszacować wartość 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)))
Wydajność
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO: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 prognozował następujące wartości:
| dom | Przepowiednia | |
|---|---|---|
| 1 | 32.29 | |
| 2 | 18.96 | |
| 3 | 27.27 | |
| 4 | 29.29 | |
| 5 | 16.43 | |
| 7 | 21.46 |
Pamiętaj, że nie znamy prawdziwej wartości . W samouczku dotyczącym głębokiego uczenia się spróbujesz pokonać model liniowy
Numpy rozwiązanie
W tej sekcji wyjaśniono, jak trenować model przy użyciu estymatora numpy w celu zasilania danymi. Metoda jest taka sama, z tą różnicą, że użyjesz estymatora numpy_input_fn.
Training_set_n = pd.read_csv(“E:/boston_train.csv”).values
test_set_n = pd.read_csv(“E:/boston_test.csv”).wartości
przewidywanie_set_n = pd.read_csv(“E:/boston_predict.csv”).wartości
Krok 1) Importuj dane
Przede wszystkim należy odróżnić zmienne cechy od etykiety. Należy to zrobić w przypadku danych szkoleniowych i oceny. Szybciej jest zdefiniować funkcję podziału 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 zbioru danych szkolenia/oceny
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Należy wykluczyć ostatnią kolumnę zbioru danych przewidywania, ponieważ zawiera ona tylko NaN
x_predict = prediction_set_n[:, :-2]
Potwierdź kształt tablicy. Należy pamiętać, że etykieta nie powinna mieć wymiaru, tzn. (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
Wydajność
(400, 9) (400,) (6, 9)
Możesz skonstruować kolumny cech w następujący sposób:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Estymator jest zdefiniowany jak poprzednio, instruujesz kolumny cech i miejsce zapisania wykresu.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
Wydajność
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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_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ć numpy estimapor, aby wprowadzić dane do modelu, a następnie wytrenować model. Zauważ, że zdefiniowaliśmy wcześniej 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)
Wydajność
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 = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO: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]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Powtarzasz 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)
Wydajność
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Na koniec możesz obliczyć prognozę. Powinno być podobnie jak z pandami.
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)))
Wydajność
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000 INFO: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 poświęcona jest rozwiązaniu TensorFlow. Ta metoda jest nieco bardziej skomplikowana niż druga.
Zwróć uwagę, że jeśli używasz Jupyter notatnik, musisz ponownie uruchomić i wyczyścić jądro, aby uruchomić tę sesję.
TensorFlow zbudował świetne narzędzie do przekazywania danych do potoku. W tej sekcji samodzielnie zbudujesz funkcję input_fn.
Krok 1) Zdefiniuj ścieżkę i format danych
Przede wszystkim deklarujesz dwie zmienne ze ścieżką do pliku csv. Zauważ, że masz dwa pliki, jeden dla zestawu treningowego 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 wszystkie. Następnie musisz zadeklarować typ zmiennej.
Zmienne pływające są definiowane 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:
- Importuj dane
- Utwórz iterator
- Korzystaj z danych
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 1
def 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 the
Dataset 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 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
** Importuj dane**
W przypadku pliku csv metoda zestawu danych odczytuje po jednym wierszu na raz. Aby zbudować zbiór danych, musisz użyć obiektu TextLineZbiór danych. Twój zbiór danych ma nagłówek, więc musisz użyć funkcji skip(1), aby pominąć pierwszą linię. W tym momencie czytasz tylko dane i wykluczasz nagłówek w potoku. Aby zasilić model, musisz oddzielić funkcje od etykiety. Metodą stosowaną do stosowania dowolnej transformacji danych jest mapa.
Ta metoda wywołuje funkcję, którą utworzysz, aby poinstruować, jak przekształcić dane. Krótko mówiąc, musisz przekazać dane w TextLineDataset, wyklucz nagłówek i zastosuj transformację zleconą przez funkcję. Wyjaśnienie kodu
- dane tf.TextLineZestaw danych (plik_danych): Ta linia odczytuje plik CSV
- .skip(1): pomiń nagłówek
- .map(parse_csv)): analizuje rekordy w tensory. Musisz zdefiniować funkcję, która będzie instruować obiekt mapy. Możesz wywołać tę funkcję parse_csv.
Ta funkcja analizuje plik csv metodą tf.decode_csv i deklaruje cechy i etykietę. Cechy mogą być deklarowane jako słownik lub krotka. Używasz metody słownikowej, ponieważ jest wygodniejsza. Wyjaśnienie kodu
- tf.decode_csv(value, record_defaults= RECORDS_ALL): metoda decode_csv wykorzystuje dane wyjściowe TextLineZbiór danych do odczytu pliku csv. record_defaults instruuje TensorFlow o typie kolumn.
- dict(zip(_CSV_COLUMNS, kolumny)): Wypełnij słownik wszystkimi kolumnami wyodrębnionymi podczas przetwarzania danych
- cechy.pop('median_house_value'): Wyklucz zmienną docelową ze zmiennej cechy i utwórz zmienną etykiety
Zbiór danych potrzebuje dalszych elementów do iteracyjnego zasilania tensorów. Rzeczywiście, musisz dodać powtórzenie metody, aby zestaw danych mógł działać w nieskończoność w celu zasilania modelu. Jeśli nie dodasz tej metody, model wykona iterację tylko raz, a następnie zgłosi błąd, ponieważ potok nie będzie już dostarczał więcej danych.
Następnie możesz kontrolować wielkość partii za pomocą metody wsadowej. Oznacza to, że informujesz zbiór danych, ile danych chcesz przekazać w potoku w 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, który zwróci elementy zbioru danych.
Najprostszym sposobem utworzenia operatora jest użycie metody make_one_shot_iterator.
Następnie możesz utworzyć funkcje i etykiety z poziomu iteratora.
Krok 4) Wykorzystaj dane
Możesz sprawdzić, co się stanie z funkcją input_fn. Aby wykorzystać dane, musisz wywołać tę funkcję w sesji. Próbujesz z wielkością partii równą 1.
Zauważ, że drukuje funkcje w słowniku i etykietę jako tablicę.
Wyświetli pierwszą linię pliku csv. Możesz spróbować uruchomić ten kod wiele razy przy różnej wielkości 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)
Wydajność
({'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')
Pamiętaj, że musisz połączyć wszystkie zmienne w wiadrze
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Krok 5) Zbuduj model
Model można trenować za pomocą estymatora LinearRegressor.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
Wydajność
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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_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 korzystasz z funkcja lambda, nie można trenować modelu.
# Train the estimatormodel.train(steps =1000,
input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
Wydajność
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 = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO: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]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
Możesz ocenić dopasowanie swojego modelu na zestawie testowym, korzystając z 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]))
Wydajność
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
Ostatnim krokiem jest przewidzenie wartości na podstawie wartości macierzy cech. Możesz napisać słownik zawierający wartości, 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 ze zbioru 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)
Wydajność
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO: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 zestaw pociągowy/testowy
- Określ wagę początkową
- Zdefiniuj funkcję straty: MSE
- Zoptymalizuj model: Zejście gradientowe
- Definiować:
- Wskaźnik uczenia się
- Numer epoki
- Wielkość partii
W tym samouczku nauczyłeś się używać interfejsu API wysokiego poziomu do estymatora regresji liniowej TensorFlow. Musisz zdefiniować:
- Kolumny funkcyjne. Jeśli ciągła: tf.feature_column.numeric_column(). Możesz wypełnić listę ze zrozumieniem listy Pythona
- Estymator: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Funkcja importująca dane, wielkość partii i epokę: input_fn()
Następnie możesz już trenować, oceniać i przewidywać za pomocą funkcji train(), Evaluator() i Predict()
