Linjär regression med TensorFlow (exempel)

Innehållsförteckning:

Anonim

Vad är linjär regression?

Linjär regression är ett tillvägagångssätt i statistik för modellering av relationer mellan två variabler. Denna modellering görs mellan ett skalärt svar och en eller flera förklarande variabler. Förhållandet med en förklarande variabel kallas enkel linjär regression och för mer än en förklarande variabel kallas den multipel linjär regression.

TensorFlow tillhandahåller verktyg för att ha full kontroll över beräkningarna. Detta görs med API på låg nivå. Dessutom är TensorFlow utrustad med ett brett utbud av API: er för att utföra många maskininlärningsalgoritmer. Detta är API på hög nivå. TensorFlow kallar dem uppskattare

  • API på låg nivå: Bygg arkitekturen, optimera modellen från grunden. Det är komplicerat för en nybörjare
  • API på hög nivå: Definiera algoritmen. Det är lättare. TensorFlow ger en verktygslåda anropsberäknaren för att konstruera, träna, utvärdera och göra en förutsägelse.

I den här handledningen använder du endast beräknarna . Beräkningarna är snabbare och enklare att genomföra. Den första delen av handledningen förklarar hur man använder gradientnedstigningsoptimeraren för att träna en linjär regression i TensorFlow. I en andra del kommer du att använda Boston-datasetet för att förutsäga priset på ett hus med hjälp av TensorFlow-estimatorn.

Ladda ner Boston DataSet

I denna TensorFlow Regression-handledning lär du dig:

  • Vad är linjär regression?
  • Hur man tränar en linjär regressionsmodell
  • Hur man tränar en linjär regression med TensorFlow
  • Pandor
  • Numpy Solution
  • Tensorflöde

Hur man tränar en linjär regressionsmodell

Innan vi börjar träna modellen, låt oss titta på vad som är en linjär regression.

Tänk dig att du har två variabler, x och y, och din uppgift är att förutsäga värdet av att känna till värdet av. Om du plottar data kan du se ett positivt förhållande mellan din oberoende variabel, x och din beroende variabel y.

Du kan observera, om x = 1, kommer y ungefär att vara lika med 6 och om x = 2, kommer y att vara runt 8,5.

Detta är inte en mycket exakt metod och benägen för fel, särskilt med en dataset med hundratusentals poäng.

En linjär regression utvärderas med en ekvation. Variabeln y förklaras av en eller flera kovariater. I ditt exempel finns det bara en beroende variabel. Om du måste skriva denna ekvation blir det:

Med:

  • är vikten associerad med x
  • är det återstående eller felet i modellen. Den innehåller vad modellen inte kan lära av data

Tänk dig att du passar modellen och att du hittar följande lösning för:

  • = 3,8
  • = 2,78

Du kan ersätta dessa siffror i ekvationen och det blir:

y = 3,8 + 2,78x

Du har nu ett bättre sätt att hitta värdena för y. Det vill säga, du kan ersätta x med vilket värde du vill förutsäga y. I bilden nedan har vi ersatt x i ekvationen med alla värden i datasetet och plottat resultatet.

Den röda linjen representerar det monterade värdet, det vill säga värdena för y för varje värde av x. Du behöver inte se värdet på x för att förutsäga y, för varje x finns det något som tillhör den röda linjen. Du kan också förutsäga för värden på x högre än 2!

Om du vill utöka den linjära regressionen till fler kovariater kan du göra det genom att lägga till fler variabler i modellen. Skillnaden mellan traditionell analys och linjär regression är att linjär regression ser på hur y kommer att reagera för varje variabel x taget oberoende.

Låt oss se ett exempel. Tänk dig att du vill förutsäga försäljningen av en glassbutik. Datauppsättningen innehåller olika uppgifter som väder (dvs. regn, sol, molnigt), kundinformation (dvs. lön, kön, civilstånd).

Traditionell analys kommer att försöka förutsäga försäljningen genom att låta oss beräkna genomsnittet för varje variabel och försöka uppskatta försäljningen för olika scenarier. Det kommer att leda till dåliga förutsägelser och begränsa analysen till det valda scenariot.

Om du använder linjär regression kan du skriva denna ekvation:

Algoritmen kommer att hitta den bästa lösningen för vikterna; det betyder att det kommer att försöka minimera kostnaden (skillnaden mellan den monterade linjen och datapunkterna).

Hur algoritmen fungerar

Algoritmen väljer ett slumpmässigt tal för varje ersätter värdet på x för att få det förutspådda värdet av y. Om datamängden har 100 observationer beräknar algoritmen 100 förutsagda värden.

Vi kan beräkna felet, noterat av modellen, vilket är skillnaden mellan det förutspådda värdet och det verkliga värdet. Ett positivt fel betyder att modellen underskattar förutsägelsen av y, och ett negativt fel betyder att modellen överskattar förutsägelsen av y.

Ditt mål är att minimera felets kvadrat. Algoritmen beräknar medelvärdet av kvadratfelet. Detta steg kallas minimering av felet. För linjär regression är Mean Square Error , även kallat MSE. Matematiskt är det:

Var:

  • hänvisar till det förutsagda värdet
  • y är de verkliga värdena
  • m är antalet observationer

Observera att det är den matematiska notationen av medelvärdet.

Målet är att hitta det bästa som minimerar MSE

Om det genomsnittliga felet är stort betyder det att modellen fungerar dåligt och att vikterna inte väljs korrekt. För att korrigera vikterna måste du använda en optimizer. Den traditionella optimeraren kallas Gradient Descent .

Gradientnedstigningen tar derivatet och minskar eller ökar vikten. Om derivatet är positivt minskar vikten. Om derivatet är negativt ökar vikten. Modellen uppdaterar vikterna och beräknar felet igen. Denna process upprepas tills felet inte ändras längre. Varje process kallas en iteration . Dessutom multipliceras lutningarna med en inlärningshastighet. Det indikerar inlärningshastigheten.

Om inlärningshastigheten är för liten tar det mycket lång tid för algoritmen att konvergera (dvs. kräver många iterationer). Om inlärningshastigheten är för hög kanske algoritmen aldrig konvergerar.

Du kan se från bilden ovan, modellen upprepar processen cirka 20 gånger tidigare för att hitta ett stabilt värde för vikterna och uppnår därför det lägsta felet.

Observera att felet inte är lika med noll utan stabiliseras runt 5. Det betyder att modellen gör ett typiskt fel på 5. Om du vill minska felet måste du lägga till mer information till modellen, till exempel fler variabler eller använda olika uppskattare.

Du kommer ihåg den första ekvationen

De slutliga vikterna är 3,8 och 2,78. Videon nedan visar hur gradientnedstigningen optimerar förlustfunktionen för att hitta denna vikt

Hur man tränar en linjär regression med TensorFlow

Nu när du har en bättre förståelse för vad som händer bakom huven är du redo att använda estimator-API som tillhandahålls av TensorFlow för att träna din första linjära regression med TensorFlow.

Du kommer att använda Boston Dataset, som innehåller följande variabler

crim per capita brottslighet per stad
zn andelen bostadsmark avsatt för delar över 25 000 kvm.
indus andel icke-detaljhandeln tunnland per stad.
nox kväveoxidkoncentration
rm genomsnittligt antal rum per bostad
ålder andelen ägarbostäder byggda före 1940
dis viktade avstånd till fem Boston-arbetsplatser
beskatta fullvärdes fastighetsskattesats per dollar 10.000
ptratio elev-lärarförhållande per stad
medv Medianvärde för ägarbostäder i tusen dollar

Du skapar tre olika datamängder:

dataset mål form
Träning Träna modellen och få vikterna 400, 10
Utvärdering Utvärdera modellens prestanda på osedda data 100, 10
Förutspå Använd modellen för att förutsäga husvärde på nya data 6, 10

Målet är att använda funktionerna i datasetet för att förutsäga värdet på huset.

Under den andra delen av handledningen lär du dig hur du använder TensorFlow med tre olika sätt att importera data:

  • Med Panda
  • Med Numpy
  • Endast TF

Observera att alla alternativ ger samma resultat.

Du lär dig hur du använder API på hög nivå för att bygga, träna och utvärdera en linjär regressionsmodell för TensorFlow. Om du använde API på låg nivå var du tvungen att definiera för hand:

  • Förlustfunktion
  • Optimera: Gradient nedstigning
  • Matriser multiplikation
  • Diagram och tensor

Detta är tråkigt och mer komplicerat för nybörjare.

Pandor

Du måste importera nödvändiga bibliotek för att träna modellen.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Steg 1) Importera data med panda.

Du definierar kolumnnamnen och lagrar det i COLUMNS. Du kan använda pd.read_csv () för att importera data.

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)

Du kan skriva ut formen på data.

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

Produktion

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

Observera att etiketten, dvs. din y, ingår i datasetet. Så du måste definiera två andra listor. En som bara innehåller funktionerna och en med endast namnet på etiketten. Dessa två listor berättar för din uppskattare vilka funktioner i datasetet och vilket kolumnnamn är etiketten

Det görs med koden nedan.

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

Steg 2) Konvertera data

Du måste konvertera de numeriska variablerna i rätt format. Tensorflow ger en metod för att konvertera kontinuerlig variabel: tf.feature_column.numeric_column ().

I föregående steg definierar du en lista över en funktion som du vill inkludera i modellen. Nu kan du använda den här listan för att konvertera dem till numeriska data. Om du vill utesluta funktioner i din modell, är du välkommen att släppa en eller flera variabler i listan FUNKTIONER innan du konstruerar feature_cols

Observera att du kommer att använda Python-listförståelse med listan FUNKTIONER för att skapa en ny lista med namnet feature_cols. Det hjälper dig att undvika att skriva nio gånger tf.feature_column.numeric_column (). En listförståelse är ett snabbare och renare sätt att skapa nya listor

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

Steg 3) Definiera uppskattaren

I det här steget måste du definiera uppskattaren. Tensorflow tillhandahåller för närvarande 6 förbyggda uppskattare, inklusive 3 för klassificeringsuppgift och 3 för TensorFlow-regressionsuppgift:

  • Regressor
    • DNNRegressor
    • Linjärregressor
    • DNNLineaCombinedRegressor
  • Klassificering
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

I denna handledning använder du Linear Regressor. För att komma åt den här funktionen måste du använda tf.estimator.

Funktionen behöver två argument:

  • feature_column: Innehåller variablerna som ska inkluderas i modellen
  • model_dir: sökväg för att lagra grafen, spara modellparametrarna etc.

Tensorflow skapar automatiskt en fil med namnet train i din arbetskatalog. Du måste använda den här sökvägen för att komma åt Tensorboard som visas i nedanstående TensorFlow-regressionsexempel.

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

Produktion

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}

Den knepiga delen med TensorFlow är sättet att mata modellen. Tensorflow är utformat för att fungera med parallell databehandling och mycket stort dataset. På grund av begränsningen av maskinresurserna är det omöjligt att mata modellen med all data på en gång. För det måste du mata en mängd data varje gång. Observera att vi pratar om enorma dataset med miljoner eller fler poster. Om du inte lägger till batch kommer du att få ett minnesfel.

Om dina data till exempel innehåller 100 observationer och du definierar en batchstorlek på 10 betyder det att modellen kommer att se 10 observationer för varje iteration (10 * 10).

När modellen har sett all information avslutas den en epok . En epok definierar hur många gånger du vill att modellen ska se data. Det är bättre att ställa in detta steg till inget och låta modellen utföra iteration antal gånger.

En andra information att lägga till är om du vill blanda informationen före varje iteration. Under träningen är det viktigt att blanda informationen så att modellen inte lär sig specifikt mönster i datasetet. Om modellen lär sig detaljerna i det underliggande datormönstret kommer det att ha svårt att generalisera förutsägelsen för osedda data. Detta kallas övermontering . Modellen presterar bra på träningsdata men kan inte förutsäga korrekt för osedda data.

TensorFlow gör dessa två steg enkla att göra. När data går till rörledningen vet den hur många observationer den behöver (batch) och om den måste blanda informationen.

För att instruera Tensorflow hur du matar modellen kan du använda pandas_input_fn. Detta objekt behöver 5 parametrar:

  • x: funktionsdata
  • y: etikettdata
  • batch_size: batch. Som standard 128
  • num_epoch: Antal epoker, som standard 1
  • shuffle: Blanda data eller inte. Som standard Ingen

Du måste mata modellen många gånger så att du definierar en funktion för att upprepa denna process. all denna funktion 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)

Den vanliga metoden för att utvärdera prestandan hos en modell är att:

  • Träna modellen
  • Utvärdera modellen i en annan dataset
  • Gör förutsägelse

Tensorflödesuppskattaren har tre olika funktioner för att enkelt utföra dessa tre steg.

Steg 4) : Träna modellen

Du kan använda estimator-tåget för att utvärdera modellen. Tåguppskattaren behöver en input_fn och ett antal steg. Du kan använda funktionen du skapade ovan för att mata modellen. Sedan instruerar du modellen att itera 1000 gånger. Observera att du inte anger antalet epoker, du låter modellen itera 100 gånger. Om du ställer in antalet epoker till 1, kommer modellen att upprepas fyra gånger: Det finns 400 poster i träningssatsen och batchstorleken är 128

  1. 128 rader
  2. 128 rader
  3. 128 rader
  4. 16 rader

Därför är det lättare att ställa in antalet epoker till ingen och definiera antalet iteration som visas i nedanstående TensorFlow klassificeringsexempel.

estimator.train(input_fn=get_input_fn(training_set,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

Produktion

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.

Du kan kontrollera Tensorboard kommer följande kommando:

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

Steg 5) Utvärdera din modell

Du kan utvärdera passformen för din modell på testuppsättningen med koden nedan:

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

Produktion

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

Du kan skriva ut förlusten med koden nedan:

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

Produktion

Loss: 3215.895996

Modellen har en förlust på 3215. Du kan kontrollera sammanfattningsstatistiken för att få en uppfattning om hur stort felet är.

training_set['medv'].describe()

Produktion

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

Från sammanfattningsstatistiken ovan vet du att genomsnittspriset för ett hus är 22 tusen, med ett minimipris på 9 tusen och högst 50 tusen. Modellen gör ett typiskt fel på 3 000 dollar.

Steg 6) Gör förutsägelsen

Slutligen kan du använda uppskattaren TensorFlow förutsäga för att uppskatta värdet av 6 Boston-hus.

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

För att skriva ut de beräknade värdena på kan du använda den här koden:

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

Produktion

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)]

Modellen förutsäger följande värden:

Hus

Förutsägelse

1

32,29

2

18,96

3

27,27

4

29.29

5

16.43

7

21.46

Observera att vi inte vet det verkliga värdet av. I handledningen för djupinlärning kommer du att försöka slå den linjära modellen

Numpy Solution

Detta avsnitt förklarar hur man tränar modellen med hjälp av en bedövad estimator för att mata in data. Metoden är samma förutom att du använder numpy_input_fn estimator.

training_set_n = pd.read_csv ("E: /boston_train.csv"). värden

test_set_n = pd.read_csv ("E: /boston_test.csv"). värden

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

Steg 1) Importera data

Först och främst måste du skilja funktionsvariablerna från etiketten. Du måste göra detta för träningsdata och utvärdering. Det är snabbare att definiera en funktion för att dela upp data.

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

Du kan använda funktionen för att dela upp etiketten från funktionerna i tåget / utvärdera dataset

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

Du måste utesluta den sista kolumnen i prediktionsdataset eftersom den bara innehåller NaN

x_predict = prediction_set_n[:, :-2]

Bekräfta formen på matrisen. Observera att etiketten inte ska ha en dimension, det betyder (400,).

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

Produktion

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

Du kan konstruera funktionskolumnerna enligt följande:

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

Uppskattaren definieras som tidigare, du instruerar funktionskolumnerna och var grafen ska sparas.

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

Produktion

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}

Du kan använda den bedövade estimoren för att mata data till modellen och sedan träna modellen. Observera att vi definierar funktionen input_fn innan för att underlätta läsbarheten.

# 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)

Produktion

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]:

Du replikerar samma steg med en annan estimator för att utvärdera din modell

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)

Produktion

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}

Slutligen, du kan beräkna förutsägelsen. Det borde vara detsamma som pandor.

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)))

Produktion

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)]

Tensorflöde

Det sista avsnittet är tillägnad en TensorFlow-lösning. Denna metod är mer komplicerad än den andra.

Observera att om du använder Jupyter notebook måste du starta om och rengöra kärnan för att köra den här sessionen.

TensorFlow har byggt ett bra verktyg för att skicka data till rörledningen. I detta avsnitt kommer du att bygga funktionen input_fn själv.

Steg 1) Definiera sökvägen och formatet på data

Först och främst förklarar du två variabler med sökvägen till csv-filen. Observera att du har två filer, en för träningsuppsättningen och en för testuppsättningen.

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

Sedan måste du definiera de kolumner du vill använda från csv-filen. Vi kommer att använda alla. Därefter måste du deklarera vilken typ av variabel det är.

Floats-variabel definieras av [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]]

Steg 2) Definiera input_fn-funktionen

Funktionen kan delas in i tre delar:

  1. Importera data
  2. Skapa itatorn
  3. Konsumera data

Nedan är överkoden för att definiera funktionen. Koden kommer att förklaras efter

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

** Importera data **

För en csv-fil läser datasetmetoden en rad i taget. För att skapa datamängden måste du använda objektet TextLineDataset. Din dataset har en rubrik så du måste hoppa över (1) för att hoppa över den första raden. Vid den här tiden läser du bara data och utesluter rubriken i rörledningen. För att mata modellen måste du skilja funktionerna från etiketten. Metoden som används för att tillämpa någon transformation till data är karta.

Den här metoden anropar en funktion som du skapar för att instruera hur du omvandlar data. I ett nötskal måste du skicka data i TextLineDataset-objektet, utesluta rubriken och tillämpa en transformation som instrueras av en funktion.

  • tf.data.TextLineDataset (data_file): Denna rad läser csv-filen
  • .skip (1): hoppa över rubriken
  • .map (parse_csv)): analysera posterna i tensorerna Du måste definiera en funktion för att instruera kartobjektet. Du kan kalla den här funktionen parse_csv.

Den här funktionen analyserar csv-filen med metoden tf.decode_csv och deklarerar funktionerna och etiketten. Funktionerna kan förklaras som en ordbok eller en tupel. Du använder ordboksmetoden eftersom det är mer praktiskt. Kodförklaring

  • tf.decode_csv (värde, record_defaults = RECORDS_ALL): metoden decode_csv använder utdata från TextLineDataset för att läsa csv-filen. record_defaults instruerar TensorFlow om kolumntypen.
  • dict (zip (_CSV_COLUMNS, kolumner)): Fyll ordboken med alla kolumner som extraherats under denna databehandling
  • features.pop ('median_house_value'): Uteslut målvariabeln från funktionsvariabeln och skapa en etikettvariabel

Dataset behöver ytterligare element för att iterativt mata Tensorerna. Du måste faktiskt lägga till metodupprepningen så att datamängden kan fortsätta på obestämd tid för att mata modellen. Om du inte lägger till metoden upprepas modellen bara en gång och kastar sedan ett fel eftersom inga fler data matas in i rörledningen.

Därefter kan du styra batchstorleken med batchmetoden. Det betyder att du berättar för datamängden hur många data du vill skicka i pipelinen för varje iteration. Om du ställer in en stor satsstorlek blir modellen långsam.

Steg 3) Skapa iteratorn

Nu är du redo för det andra steget: skapa en iterator för att returnera elementen i datasetet.

Det enklaste sättet att skapa en operatör är med metoden make_one_shot_iterator.

Därefter kan du skapa funktioner och etiketter från iteratorn.

Steg 4) Konsumera data

Du kan kontrollera vad som händer med input_fn-funktionen. Du måste ringa funktionen i en session för att konsumera data. Du försöker med en satsstorlek som är lika med 1.

Observera att den skriver ut funktionerna i en ordlista och etiketten som en matris.

Den visar den första raden i csv-filen. Du kan försöka köra den här koden många gånger med olika batchstorlek.

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)

Produktion

({'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))

Steg 4) Definiera funktionskolumnen

Du måste definiera de numeriska kolumnerna enligt följande:

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')

Observera att du måste kombinera alla variabler i en hink

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

Steg 5) Bygg modellen

Du kan träna modellen med estimatorn LinearRegressor.

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

Produktion

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}

Du måste använda en lambda-funktion för att kunna skriva argumentet i funktionen inpu_fn. Om du inte använder en lambda-funktion kan du inte träna modellen.

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

Produktion

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]:

Du kan utvärdera passformen för din modell på testuppsättningen med koden nedan:

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]))

Produktion

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

Det sista steget är att förutsäga värdet av baserat på värdet på funktionerna. Du kan skriva en ordbok med de värden du vill förutsäga. Din modell har 9 funktioner så du måste ange ett värde för varje. Modellen ger en förutsägelse för var och en av dem.

I koden nedan skrev du värdena för varje funktion som finns i df_predict csv-filen.

Du måste skriva en ny input_fn-funktion eftersom det inte finns någon etikett i datasetet. Du kan använda API: et från_tensor från datamängden.

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)

Slutligen, du skriver ut förutsägelserna.

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

Produktion

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)})

Sammanfattning

För att träna en modell måste du:

  • Definiera funktioner: Oberoende variabler: X
  • Definiera etiketten: Beroende variabel: y
  • Konstruera ett tåg / testuppsättning
  • Definiera den ursprungliga vikten
  • Definiera förlustfunktionen: MSE
  • Optimera modellen: Gradient nedstigning
  • Definiera:
    • Inlärningshastighet
    • Antal epoker
    • Satsstorlek

I den här självstudien lärde du dig hur du använder API på hög nivå för en linjär regressions TensorFlow-estimator. Du måste definiera:

  1. Funktionskolumner. Om kontinuerlig: tf.feature_column.numeric_column (). Du kan fylla i en lista med pythonlistförståelse
  2. Uppskattaren: tf.estimator.LinearRegressor (feature_column, model_dir)
  3. En funktion för att importera data, batchstorlek och epok: input_fn ()

Efter det är du redo att träna, utvärdera och förutsäga med tåg (), utvärdera () och förutsäga ()