Regressão linear com TensorFlow (exemplos)

Índice:

Anonim

O que é regressão linear?

A regressão linear é uma abordagem em estatística para modelar relacionamentos entre duas variáveis. Essa 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 é equipado com uma vasta gama de APIs para executar muitos algoritmos de aprendizado de máquina. Esta é a API de alto nível. TensorFlow os chama de estimadores

  • API de baixo nível: Construir a arquitetura, otimização do modelo a partir do zero. É complicado para um iniciante
  • API de alto nível: defina o algoritmo. É mais fácil de usar. O TensorFlow fornece um estimador de chamadas de caixa de ferramentas para construir, treinar, avaliar e fazer uma previsão.

Neste tutorial, você usará apenas os estimadores . 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. Em uma segunda parte, você usará o conjunto de dados de Boston para prever o preço de uma casa usando o estimador TensorFlow.

Baixar Boston DataSet

Neste tutorial de regressão do TensorFlow, você aprenderá:

  • O que é regressão linear?
  • Como treinar um modelo de regressão linear
  • Como treinar uma regressão linear com TensorFlow
  • Pandas
  • Solução Numpy
  • Solução Tensorflow

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, xey, e sua tarefa é prever o valor de saber 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.

Você pode observar, 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 várias covariáveis. Em seu exemplo, há apenas uma variável dependente. Se você tiver que escrever esta equação, será:

Com:

  • é o peso associado a x
  • é 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 a seguinte solução para:

  • = 3,8
  • = 2,78

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

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 deseja prever y. Na imagem abaixo, substituímos x na equação por todos os valores do conjunto de dados e plotamos o resultado.

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 pertence à linha vermelha. Você também pode prever valores de x maiores que 2!

Se você deseja estender a regressão linear para mais covariáveis, pode 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 tomada independentemente.

Vamos ver um exemplo. Imagine que você queira prever as vendas de uma sorveteria. O conjunto de dados contém informações diferentes, como o 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, computando a média de 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:

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 funciona o algoritmo

O algoritmo escolherá um número aleatório para cada substituirá 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, observado 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.

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 a regressão linear é o erro quadrático médio , também denominado MSE. Matematicamente, é:

Onde:

  • se referem ao valor previsto
  • y são os valores reais
  • m é o número de observações

Observe que é a notação matemática da média.

O objetivo é encontrar o que melhor minimiza 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, você precisa usar um otimizador. O otimizador tradicional é denominado Gradient Descent .

A descida gradiente toma a derivada e diminui ou aumenta o peso. Se a derivada for positiva, o peso é reduzido. 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 aprendizado for muito pequena, levará muito tempo para o algoritmo convergir (ou seja, requer muitas iterações). Se a taxa de aprendizado for muito alta, o algoritmo pode nunca convergir.

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

Observe que o erro não é igual a zero, mas 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

Os pesos finais são 3,8 e 2,78. O vídeo abaixo mostra como o gradiente descendente otimiza a função de perda para encontrar esses pesos

Como treinar uma regressão linear com TensorFlow

Agora que você tem uma compreensão melhor do 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 Boston, que inclui as seguintes variáveis

crim taxa de crime 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 acres de negócios 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 pelo proprietário construídas antes de 1940
dis distâncias ponderadas para cinco centros de empregos de Boston
imposto taxa de imposto sobre a propriedade de valor total por US $ 10.000
ptratio proporção aluno-professor por cidade
medv Valor médio das casas ocupadas pelo proprietário em mil dólares

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

conjunto de dados objetivo forma
Treinamento 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 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 Numpy
  • Apenas TF

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

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

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

Isso é tedioso e mais complicado para o iniciante.

Pandas

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

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Etapa 1) Importe os dados com o 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 = COLUMNS)

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

Resultado

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

Observe que o rótulo, ou seja, seu y, está incluído no conjunto de dados. Portanto, 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 no 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"

Etapa 2) Converter os dados

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

Na etapa anterior, você define uma lista de um recurso que deseja incluir no modelo. Agora você pode usar essa lista para convertê-los em dados numéricos. Se você deseja excluir recursos em seu modelo, sinta-se à vontade para soltar uma ou mais variáveis ​​na lista FEATURES antes de construir o 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. Ajuda a evitar escrever nove vezes tf.feature_column.numeric_column (). A compreensão de uma lista é uma maneira mais rápida e limpa de criar novas listas

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

Etapa 3) Definir o estimador

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

  • Regressor
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Classificador
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

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

Resultado

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}

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 vez. Para isso, você precisa alimentar um lote de dados a cada vez. Observe que estamos falando de um enorme conjunto de dados com milhões ou mais registros. Se você não adicionar o lote, terá um erro de memória.

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

Quando o modelo tiver visto todos os dados, ele termina uma época . Uma época define quantas vezes você deseja que o modelo veja os dados. É melhor definir essa etapa como nenhum e deixar o modelo realizar a iteração por número de tempo.

Uma segunda informação a adicionar é 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 o padrão específico do conjunto de dados. Se o modelo aprender os detalhes do padrão subjacente dos dados, terá dificuldades para generalizar a previsão para dados não vistos. Isso é chamado de overfitting . O modelo tem um bom desempenho nos dados de treinamento, mas não pode prever corretamente os dados não vistos.

O TensorFlow facilita essas duas etapas. Quando os dados vão para o pipeline, ele sabe de quantas observações precisa (lote) e se precisa 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 de recursos
  • y: dados do rótulo
  • batch_size: batch. Por padrão 128
  • num_epoch: número de época, por padrão 1
  • shuffle: Shuffle ou não os dados. Por padrão, nenhum

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

Etapa 4) : treinar o modelo

Você pode usar o trem do estimador para avaliar o modelo. O estimador de trem precisa de um input_fn e 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: há 400 registros no conjunto de treinamento e o tamanho do lote é 128

  1. 128 linhas
  2. 128 linhas
  3. 128 linhas
  4. 16 linhas

Portanto, é mais fácil definir o número de época 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)

Resultado

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.

Você pode verificar o Tensorboard com o seguinte comando:

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

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

Resultado

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

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

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

Resultado

Loss: 3215.895996

O modelo tem uma perda de 3215. Você pode verificar a estatística de resumo para ter uma ideia de quão grande é o erro.

training_set['medv'].describe()

Resultado

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

Pela estatística resumida 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.

Etapa 6) Faça a previsão

Por fim, você pode usar o estimador de previsão do TensorFlow para estimar o valor de 6 casas de 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)))

Resultado

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

O modelo prevê os seguintes valores:

casa

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á superar 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

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

Etapa 1) Importar os dados

Em primeiro lugar, 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 contém apenas NaN

x_predict = prediction_set_n[:, :-2]

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

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

Resultado

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

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

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

Resultado

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}

Você pode usar a estimativa numpy para alimentar os dados do 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)

Resultado

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

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)

Resultado

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}

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

Resultado

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

Solução Tensorflow

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

Observe que se você usar o notebook Jupyter, será necessário reiniciar e limpar o kernel para executar esta sessão.

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

Etapa 1) Definir o caminho e o formato dos dados

Em primeiro lugar, 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 teste.

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

Etapa 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 após

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

** Importe os dados **

Para um arquivo csv, o método do conjunto de dados lê uma linha por vez. Para construir o conjunto de dados, você precisa usar o objeto TextLineDataset. 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 é map.

Este método chama uma função que você criará para instruir como transformar os dados. Em poucas palavras, você precisa passar os dados no objeto TextLineDataset, excluir o cabeçalho e aplicar uma transformação que é instruída por uma função. Explicação do código

  • tf.data.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 parse_csv.

Esta função analisa o arquivo csv com o método tf.decode_csv e declara os recursos e o rótulo. Os recursos podem ser declarados como um dicionário ou uma tupla. Você usa o método do 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 TextLineDataset para ler o arquivo csv. record_defaults instrui o TensorFlow sobre o tipo de colunas.
  • dict (zip (_CSV_COLUMNS, colunas)): Preencher 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 os tensores de forma iterativa. Na verdade, você precisa adicionar a repetição do método para permitir que o conjunto de dados continue indefinidamente para alimentar o modelo. Se você não adicionar o método, o modelo irá iterar apenas uma vez e, em seguida, lançar um erro porque nenhum outro dado é alimentado no pipeline.

Depois disso, você pode controlar o tamanho do lote com o método de 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 ficará lento.

Etapa 3) Crie o iterador

Agora você está pronto para a segunda etapa: crie um iterador para retornar os elementos no 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 uma matriz.

Ele mostrará a primeira linha do arquivo csv. Você pode tentar executar esse código muitas 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)

Resultado

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

Etapa 4) Definir a coluna de recurso

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]

Etapa 5) Construir o modelo

Você pode treinar o modelo com o estimador LinearRegressor.

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

Resultado

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}

Você precisa usar uma função lambda para permitir a escrita do argumento na função inpu_fn. Se você não usar uma função lambda, 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))

Resultado

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

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

Resultado

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

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, portanto, você precisa fornecer um valor para cada um. O modelo fornecerá uma previsão para cada um deles.

No código a seguir, 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)

Resultado

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

Resumo

Para treinar um modelo, você precisa:

  • Defina as características: Variáveis ​​independentes: X
  • Defina o rótulo: Variável dependente: y
  • Construir um trem / conjunto de teste
  • Defina o peso inicial
  • Defina a função de perda: MSE
  • Otimize o modelo: descida gradiente
  • 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 TensorFlow de regressão linear. 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 treinar (), avaliar () e prever ()