Tutorial de regressão linear com TensorFlow [exemplos]

O que é regressão linear?

Regressão linear é uma abordagem em estatística para modelar relações entre duas variáveis. Esta modelagem é feita entre uma resposta escalar e uma ou mais variáveis ​​explicativas. A relação com uma variável explicativa é chamada de regressão linear simples e para mais de uma variável explicativa é chamada de regressão linear múltipla.

O TensorFlow fornece ferramentas para ter controle total dos cálculos. Isso é feito com a API de baixo nível. Além disso, o TensorFlow está equipado com uma vasta gama de APIs para realizar muitas aprendizado de máquina algoritmos. Esta é a API de alto nível. TensorFlow os chama de estimadores

  • API de baixo nível: Construa o archiarquitetura, otimização do modelo do zero. É complicado para um iniciante
  • API de alto nível: Defina o algoritmo. É mais fácil. TensorFlow fornece uma ferramentabox chamado estimador para construir, treinar, avaliar e fazer uma previsão.

Neste tutorial, você usará o estimadores apenas. Os cálculos são mais rápidos e mais fáceis de implementar. A primeira parte do tutorial explica como usar o otimizador de gradiente descendente para treinar uma regressão linear no TensorFlow. Na segunda parte, você usará o conjunto de dados de Boston para prever o preço de uma casa usando o estimador TensorFlow.

Baixe o conjunto de dados de Boston

Como treinar um modelo de regressão linear

Antes de começarmos a treinar o modelo, vamos dar uma olhada no que é uma regressão linear.

Imagine que você tem duas variáveis, x e y, e sua tarefa é prever o valor de knowing o valor de . Se você plotar os dados, poderá ver uma relação positiva entre sua variável independente, x, e sua variável dependente y.

Treine um modelo de regressão linear

Você pode observar que se x=1,y será aproximadamente igual a 6 e se x=2,y será em torno de 8.5.

Este não é um método muito preciso e sujeito a erros, especialmente com um conjunto de dados com centenas de milhares de pontos.

Uma regressão linear é avaliada com uma equação. A variável y é explicada por uma ou mais covariáveis. No seu exemplo, há apenas uma variável dependente. Se você tiver que escrever esta equação, será:

Treine um modelo de regressão linear

Com:

  • Regressão Linear com TensorFlow é o preconceito. ou seja, se x=0, y=Treine um modelo de regressão linear
  • Treine um modelo de regressão linear é o peso associado a x
  • Treine um modelo de regressão linear é o resíduo ou o erro do modelo. Inclui o que o modelo não pode aprender com os dados

Imagine que você se encaixa no modelo e encontra o seguintewing solução para:

  • Treine um modelo de regressão linear = 3.8
  • Treine um modelo de regressão linear = 2.78

Você pode substituir esses números na equação e ela se tornará:

y = 3.8 + 2.78x

Agora você tem uma maneira melhor de encontrar os valores de y. Ou seja, você pode substituir x por qualquer valor que queira prever y. Na imagem abaixo, substituímos x na equação por todos os valores do conjunto de dados e traçamos o resultado.

Treine um modelo de regressão linear

A linha vermelha representa o valor ajustado, ou seja, os valores de y para cada valor de x. Você não precisa ver o valor de x para prever y, para cada x existe algum que pertença à linha vermelha. Você também pode prever valores de x maiores que 2!

Se quiser estender a regressão linear para mais covariáveis, você poderá adicionar mais variáveis ​​ao modelo. A diferença entre a análise tradicional e a regressão linear é que a regressão linear analisa como y reagirá para cada variável x considerada independentemente.

Vejamos um exemplo. Imagine que você deseja prever as vendas de uma sorveteria. O conjunto de dados contém informações diversas, como clima (ou seja, chuvoso, ensolarado, nublado), informações do cliente (ou seja, salário, sexo, estado civil).

A análise tradicional tentará prever a venda, digamos, calculando a média para cada variável e tentar estimar a venda para diferentes cenários. Isso levará a previsões ruins e restringirá a análise ao cenário escolhido.

Se você usar regressão linear, poderá escrever esta equação:

Treine um modelo de regressão linear

O algoritmo encontrará a melhor solução para os pesos; significa que tentará minimizar o custo (a diferença entre a linha ajustada e os pontos de dados).

Como o algoritmo funciona

Funcionamento do Algoritmo

O algoritmo escolherá um número aleatório para cada Regressão Linear com TensorFlow e Funcionamento do Algoritmo e substitua o valor de x para obter o valor previsto de y. Se o conjunto de dados tiver 100 observações, o algoritmo calcula 100 valores previstos.

Podemos calcular o erro, notado Funcionamento do Algoritmo do modelo, que é a diferença entre o valor previsto e o valor real. Um erro positivo significa que o modelo subestima a previsão de y, e um erro negativo significa que o modelo superestima a previsão de y.

Funcionamento do Algoritmo

Seu objetivo é minimizar o quadrado do erro. O algoritmo calcula a média do erro quadrado. Esta etapa é chamada de minimização do erro. Para regressão linear é o Erro quadrado médio, também chamado de MSE. Matematicamente, é:

Funcionamento do Algoritmo

Onde:

  • Funcionamento do Algoritmo os pesos são assim Funcionamento do Algoritmo refere-se ao valor previsto
  • y são os valores reais
  • m é o número de observações

Observe que Funcionamento do Algoritmo significa que usa a transposta das matrizes. O Funcionamento do Algoritmo é a notação matemática da média.

O objetivo é encontrar o melhor Funcionamento do Algoritmo que minimizam o MSE

Se o erro médio for grande, significa que o modelo tem um desempenho ruim e os pesos não foram escolhidos corretamente. Para corrigir os pesos, é necessário usar um otimizador. O otimizador tradicional é chamado Gradiente descendente.

A descida gradiente leva a derivada e diminui ou aumenta o peso. Se a derivada for positiva, o peso diminui. Se a derivada for negativa, o peso aumenta. O modelo atualizará os pesos e recalculará o erro. Este processo é repetido até que o erro não mude mais. Cada processo é chamado de iteração. Além disso, os gradientes são multiplicados por uma taxa de aprendizagem. Indica a velocidade do aprendizado.

Se a taxa de aprendizagem for muito pequena, levará muito tempo para o algoritmo convergir (ou seja, requer muitas iterações). Se a taxa de aprendizagem for muito alta, o algoritmo poderá nunca convergir.

Funcionamento do Algoritmo

Como você pode ver na foto acima, o modelo repete o processo cerca de 20 vezes antes para encontrar um valor estável para os pesos, atingindo assim o menor erro.

Observe que, o erro não é igual a zero, mas se estabiliza em torno de 5. Isso significa que o modelo comete um erro típico de 5. Se quiser reduzir o erro, você precisa adicionar mais informações ao modelo, como mais variáveis, ou usar estimadores diferentes .

Você se lembra da primeira equação

Funcionamento do Algoritmo

Os pesos finais são 3.8 e 2.78. O vídeo abaixo mostra como a descida do gradiente otimiza a função de perda para encontrar esses pesos

Como treinar uma regressão linear com TensorFlow

Agora que você entende melhor o que está acontecendo nos bastidores, está pronto para usar a API do estimador fornecida pelo TensorFlow para treinar sua primeira regressão linear usando o TensorFlow.

Você usará o conjunto de dados de Boston, que inclui o seguintewing variáveis

criminoso taxa de criminalidade per capita por cidade
zn proporção de terrenos residenciais zoneados para lotes com mais de 25,000 pés quadrados.
indus proporção de hectares comerciais não varejistas por cidade.
nox concentração de óxidos nítricos
rm número médio de quartos por habitação
idade proporção de unidades ocupadas pelos proprietários construídas antes de 1940
dis distâncias ponderadas para cinco centros de emprego de Boston
imposto taxa de imposto sobre a propriedade de valor total por dólares 10,000
ptratio proporção aluno-professor por cidade
medv Valor médio das casas ocupadas pelos proprietários em milhares de dólares

Você criará três conjuntos de dados diferentes:

conjunto de dados objetivo forma
Training Treine o modelo e obtenha os pesos 400, 10
Avaliação Avalie o desempenho do modelo em dados não vistos 100, 10
Prever Use o modelo para prever o valor da casa com base em novos dados 6, 10

O objetivo é usar os recursos do conjunto de dados para prever o valor da casa.

Durante a segunda parte do tutorial, você aprenderá como usar o TensorFlow com três maneiras diferentes de importar os dados:

  • Com pandas
  • Com o Numpy
  • Apenas TF

Observe que todas as opções fornecer os mesmos resultados.

Você aprenderá como usar a API de alto nível para criar, treinar e avaliar um modelo de regressão linear do TensorFlow. Se você estivesse usando a API de baixo nível, teria que definir manualmente:

  • Função de perda
  • Otimizar: gradiente descendente
  • Multiplicação de matrizes
  • Gráfico e tensor

Isso é tedioso e mais complicado para iniciantes.

Pandas

Você precisa importar as bibliotecas necessárias para treinar o modelo.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

Passo 1) Importe os dados com panda.

Você define os nomes das colunas e os armazena em COLUNAS. Você pode usar pd.read_csv() para importar os dados.

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

training_set = pd.read_csv(“E:/boston_train.csv”, skipinitialspace=True,skiprows=1, nomes=COLUMNS)

test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, nomes=COLUNAS)

predição_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, nomes=COLUMNS)

Você pode imprimir a forma dos dados.

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

saída

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

Observe que o rótulo, ou seja, seu y, está incluído no conjunto de dados. Então você precisa definir duas outras listas. Um contendo apenas os recursos e outro apenas com o nome do rótulo. Essas duas listas dirão ao seu estimador quais são os recursos do conjunto de dados e qual nome de coluna é o rótulo

Isso é feito com o código abaixo.

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

Passo 2) Converta os dados

Você precisa converter as variáveis ​​numéricas no formato adequado. Tensorflow fornece um método para converter variável contínua: tf.feature_column.numeric_column().

Na etapa anterior, você define uma lista de recursos que deseja incluir no modelo. Agora você pode usar esta lista para convertê-los em dados numéricos. Se você deseja excluir recursos em seu modelo, sinta-se à vontade para colocar uma ou mais variáveis ​​na lista FEATURES antes de construir feature_cols

Observe que você usará a compreensão de lista do Python com a lista FEATURES para criar uma nova lista chamada feature_cols. Isso ajuda você a evitar escrever nove vezes tf.feature_column.numeric_column(). A compreensão de listas é uma maneira mais rápida e limpa de criar novas listas

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

Passo 3) Defina o estimador

Nesta etapa, você precisa definir o estimador. Atualmente, o Tensorflow fornece 6 estimadores pré-construídos, incluindo 3 para tarefas de classificação e 3 para tarefas de regressão do TensorFlow:

  • Regressor
    • DNSRegressor
    • Regressor Linear
    • DNNLineaCombinedRegressor
  • classificar
    • Classificador DNN
    • Classificador Linear
    • Classificador DNNLineaCombined

Neste tutorial, você usará o Regressor Linear. Para acessar esta função, você precisa usar tf.estimator.

A função precisa de dois argumentos:

  • feature_columns: Contém as variáveis ​​a serem incluídas no modelo
  • model_dir: caminho para armazenar o gráfico, salvar os parâmetros do modelo, etc.

O Tensorflow criará automaticamente um arquivo chamado train em seu diretório de trabalho. Você precisa usar este caminho para acessar o Tensorboard, conforme mostrado no exemplo de regressão do TensorFlow abaixo.

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

saída

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}

A parte complicada do TensorFlow é a maneira de alimentar o modelo. O Tensorflow foi projetado para funcionar com computação paralela e conjuntos de dados muito grandes. Devido à limitação dos recursos da máquina, é impossível alimentar o modelo com todos os dados de uma só vez. Para isso, você precisa alimentar um lote de dados de cada vez. Observe que estamos falando de um enorme conjunto de dados com milhões ou mais de registros. Se você não adicionar lote, ocorrerá um erro de memória.

Por exemplo, se seus dados contiverem 100 observações e você definir um tamanho de lote de 10, isso significa que o modelo verá 10 observações para cada iteração (10*10).

Quando o modelo tiver visto todos os dados, ele termina um época. Uma época define quantas vezes você deseja que o modelo veja os dados. É melhor definir esta etapa como nenhuma e deixar o modelo executar o número de iterações.

Uma segunda informação a ser adicionada é se você deseja embaralhar os dados antes de cada iteração. Durante o treinamento, é importante embaralhar os dados para que o modelo não aprenda um padrão específico do conjunto de dados. Se o modelo aprender o details do padrão subjacente dos dados, terá dificuldades em generalizar a previsão para dados não vistos. Isso é chamado sobreajuste. O modelo tem um bom desempenho nos dados de treinamento, mas não consegue prever corretamente dados não vistos.

O TensorFlow facilita essas duas etapas. Quando os dados vão para o pipeline, ele sabe quantas observações são necessárias (lote) e se é necessário embaralhar os dados.

Para instruir o Tensorflow sobre como alimentar o modelo, você pode usar pandas_input_fn. Este objeto precisa de 5 parâmetros:

  • x: dados do recurso
  • y: dados do rótulo
  • tamanho_do_lote: lote. Por padrão 128
  • num_epoch: Número da época, por padrão 1
  • shuffle: Embaralha ou não os dados. Por padrão, Nenhum

Você precisa alimentar o modelo várias vezes para definir uma função para repetir esse processo. toda essa função 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)

O método usual para avaliar o desempenho de um modelo é:

  • Treine o modelo
  • Avalie o modelo em um conjunto de dados diferente
  • Fazer previsão

O estimador Tensorflow fornece três funções diferentes para realizar essas três etapas facilmente.

Passo 4): Treine o modelo

Você pode usar o trem de estimadores para avaliar o modelo. O estimador de trem precisa de um input_fn e de uma série de etapas. Você pode usar a função criada acima para alimentar o modelo. Em seguida, você instrui o modelo a iterar 1000 vezes. Observe que você não especifica o número de épocas, mas permite que o modelo itere 1000 vezes. Se você definir o número de época como 1, o modelo irá iterar 4 vezes: Existem 400 registros no conjunto de treinamento e o tamanho do lote é 128

  1. 128 camadas
  2. 128 camadas
  3. 128 camadas
  4. 16 camadas

Portanto, é mais fácil definir o número de épocas como nenhum e definir o número de iterações conforme mostrado no exemplo de classificação do TensorFlow abaixo.

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

saída

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.

Você pode verificar o Tensorboard no seguintewing comando:

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

Passo 5) Avalie seu modelo

Você pode avaliar o ajuste do seu modelo no conjunto de teste com o código abaixo:

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

saída

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

Você pode imprimir a perda com o código abaixo:

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

saída

Loss: 3215.895996

O modelo tem uma perda de 3215. Você pode verificar a estatística resumida para ter uma ideia do tamanho do erro.

training_set['medv'].describe()

saída

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

Pelo resumo estatístico acima, você sabe que o preço médio de uma casa é de 22 mil, com preço mínimo de 9 mil e máximo de 50 mil. O modelo comete um erro típico de 3 mil dólares.

Passo 6) Faça a previsão

Finalmente, você pode usar o estimador de previsão do TensorFlow para estimar o valor de 6 casas em Boston.

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

Para imprimir os valores estimados de , você pode usar este código:

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

saída

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

O modelo previu o seguintewing valores:

House Predição
1 32.29
2 18.96
3 27.27
4 29.29
5 16.43
7 21.46

Observe que não sabemos o verdadeiro valor de . No tutorial de aprendizado profundo, você tentará vencer o modelo linear

Solução numpy

Esta seção explica como treinar o modelo usando um estimador numpy para alimentar os dados. O método é o mesmo, exceto que você usará o estimador numpy_input_fn.

training_set_n = pd.read_csv(“E:/boston_train.csv”).valores

test_set_n = pd.read_csv(“E:/boston_test.csv”).valores

predição_set_n = pd.read_csv(“E:/boston_predict.csv”).valores

Passo 1) Importar os dados

Primeiro de tudo, você precisa diferenciar as variáveis ​​de recurso do rótulo. Você precisa fazer isso para os dados de treinamento e avaliação. É mais rápido definir uma função para dividir os dados.

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

Você pode usar a função para dividir o rótulo dos recursos do conjunto de dados de treinamento/avaliação

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

Você precisa excluir a última coluna do conjunto de dados de previsão porque ela contém apenas NaN

x_predict = prediction_set_n[:, :-2]

Confirme a forma da matriz. Observe que o rótulo não deve ter dimensão, significa (400,).

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

saída

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

Você pode construir as colunas de recursos da seguinte maneira:

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

O estimador é definido como antes, você instrui as colunas de recursos e onde salvar o gráfico.

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

saída

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}

Você pode usar o numpy estimapor para alimentar os dados no modelo e, em seguida, treinar o modelo. Observe que definimos a função input_fn antes para facilitar a legibilidade.

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

saída

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>

Você replica a mesma etapa com um estimador diferente para avaliar seu modelo

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)

saída

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}

Finalmente, você pode calcular a previsão. Deve ser semelhante aos pandas.

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

saída

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

Solução Tensorflow

A última seção é dedicada a uma solução TensorFlow. Este método é um pouco mais complicado que o outro.

Observe que se você usar Jupyter caderno, você precisa reiniciar e limpar o kernel para executar esta sessão.

TensorFlow construiu uma ótima ferramenta para passar os dados para o pipeline. Nesta seção, você mesmo construirá a função input_fn.

Passo 1) Defina o caminho e o formato dos dados

Primeiro de tudo, você declara duas variáveis ​​com o caminho do arquivo csv. Observe que você tem dois arquivos, um para o conjunto de treinamento e outro para o conjunto de testes.

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

Em seguida, você precisa definir as colunas que deseja usar no arquivo csv. Usaremos todos. Depois disso, você precisa declarar o tipo de variável.

Variáveis ​​flutuantes são definidas por [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]]

Passo 2) Defina a função input_fn

A função pode ser dividida em três partes:

  1. Importar os dados
  2. Crie o iterador
  3. Consumir os dados

Abaixo está o código geral para definir a função. O código será explicado depois

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

** Importe os dados**

Para um arquivo csv, o método dataset lê uma linha por vez. Para construir o conjunto de dados, você precisa usar o objeto TextLineConjunto de dados. Seu conjunto de dados tem um cabeçalho, então você precisa usar skip(1) para pular a primeira linha. Neste ponto, você apenas lê os dados e exclui o cabeçalho do pipeline. Para alimentar o modelo, você precisa separar os recursos do rótulo. O método usado para aplicar qualquer transformação aos dados é o mapa.

Este método chama uma função que você criará para instruir como transformar os dados. Resumindo, você precisa passar os dados no TextLineObjeto conjunto de dados, exclua o cabeçalho e aplique uma transformação que é instruída por uma função.Explicação do código

  • tf.dados.TextLineDataset(data_file): Esta linha lê o arquivo csv
  • .skip(1): pula o cabeçalho
  • .map (parse_csv)): analisa os registros nos tensores. Você precisa definir uma função para instruir o objeto do mapa. Você pode chamar esta função de parse_csv.

Esta função analisa o arquivo csv com o método tf.decode_csv e declares os recursos e o rótulo. Os recursos podem ser declarados como um dicionário ou uma tupla. Você usa o método de dicionário porque é mais conveniente. Explicação do código

  • tf.decode_csv(value, record_defaults= RECORDS_ALL): o método decode_csv usa a saída do TextLineConjunto de dados para ler o arquivo csv. record_defaults instrui o TensorFlow sobre o tipo de colunas.
  • dict(zip(_CSV_COLUMNS, columns)): Preencha o dicionário com todas as colunas extraídas durante este processamento de dados
  • features.pop('median_house_value'): Exclua a variável de destino da variável de recurso e crie uma variável de rótulo

O conjunto de dados precisa de mais elementos para alimentar iterativamente os tensores. Na verdade, você precisa adicionar o método repeat para permitir que o conjunto de dados continue indefinidamente alimentando o modelo. Se você não adicionar o método, o modelo iterará apenas uma vez e gerará um erro porque nenhum outro dado será alimentado no pipeline.

Depois disso, você pode controlar o tamanho do lote com o método em lote. Isso significa que você informa ao conjunto de dados quantos dados deseja passar no pipeline para cada iteração. Se você definir um tamanho de lote grande, o modelo será lento.

Etapa 3) Crie o iterador

Agora você está pronto para a segunda etapa: crie um iterador para retornar os elementos do conjunto de dados.

A maneira mais simples de criar um operador é com o método make_one_shot_iterator.

Depois disso, você pode criar os recursos e rótulos do iterador.

Etapa 4) Consumir os dados

Você pode verificar o que acontece com a função input_fn. Você precisa chamar a função em uma sessão para consumir os dados. Você tenta com um tamanho de lote igual a 1.

Observe que ele imprime os recursos em um dicionário e o rótulo como um array.

Ele mostrará a primeira linha do arquivo csv. Você pode tentar executar esse código várias vezes com tamanhos de lote diferentes.

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)

saída

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

Passo 4) Defina a coluna de recursos

Você precisa definir as colunas numéricas da seguinte forma:

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

Observe que você precisa combinar todas as variáveis ​​em um intervalo

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

Passo 5) Construa o modelo

Você pode treinar o modelo com o estimador LinearRegressor.

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

saída

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}

Você precisa usar uma função lambda para permitir escrever o argumento na função inpu_fn. Se você não usar um função lambda, você não poderá treinar o modelo.

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

saída

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>

Você pode avaliar o ajuste do seu modelo no conjunto de teste com o código abaixo:

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

saída

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

A última etapa é prever o valor de com base no valor de , as matrizes dos recursos. Você pode escrever um dicionário com os valores que deseja prever. Seu modelo possui 9 recursos, então você precisa fornecer um valor para cada um. O modelo fornecerá uma previsão para cada um deles.

No código abaixo, você escreveu os valores de cada recurso contido no arquivo csv df_predict.

Você precisa escrever uma nova função input_fn porque não há rótulo no conjunto de dados. Você pode usar a API from_tensor do conjunto de dados.

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)

Finalmente, você imprime as previsões.

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

saída

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

Resumo

Para treinar um modelo, você precisa:

  • Defina os recursos: Variáveis ​​independentes: X
  • Defina o rótulo: Variável dependente: y
  • Construa um conjunto de treinamento/teste
  • Defina o peso inicial
  • Defina a função de perda: MSE
  • Otimize o modelo: gradiente descendente
  • Definir:
    • Taxa de Aprendizagem
    • Número de época
    • Tamanho do batch

Neste tutorial, você aprendeu como usar a API de alto nível para um estimador de regressão linear do TensorFlow. Você precisa definir:

  1. Colunas de recursos. Se contínuo: tf.feature_column.numeric_column(). Você pode preencher uma lista com compreensão de lista python
  2. O estimador: tf.estimator.LinearRegressor(feature_columns, model_dir)
  3. Uma função para importar os dados, o tamanho do lote e a época: input_fn()

Depois disso, você está pronto para treinar, avaliar e fazer previsões com train(), avaliar() e prever()