tf.estimator.LinearClassifier – classificador linear clássico, constrói um modelo de classificação linear
tf.estimator.LinearRegressor – constrói um modelo de regressão linear
tf.estimator.DNNClassifier – constrói um modelo de classificador usando uma rede neural densamente conectada
tf.estimator.DNNRegressor – constrói um modelo de regressão usando uma rede neural densamente conectada
tf.estimator.DNNLinearCombinedClassifier – constrói uma rede neural e um modelo de classificação linear combinado
tf.estimator.DNNLinearCombinedClassifier – constrói uma rede neural e um modelo de regressão linear combinado
entre outros…

O formato para usar essa API de estimador é o seguinte:

Definir uma lista de variáveis independentes, ou seja, as características dos dados, enfim, as features.
Criar o modelo estimador
Criar a função de entrada de dados
Chamar os métodos train, evaluate e predict no objeto estimador

TF Estimator

Vamos criar um estimador bem simples, teremos apenas uma feature.


import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
#gerando os dados lineares
x_data = np.linspace(0.0, 10.0, 1000000)
#cria o ruído para adicionar aos dados, e ficarem parecidos com dados mais reais
noise = np.random.randn(len(x_data))
#Adicionamos o ruído aos dados
y_true = (0.5 * x_data) + 5 + noise
#Cria os dataframes pandas com os dados
x_df = pd.DataFrame(data = x_data, columns = ['X Data'])
y_df = pd.DataFrame(data = y_true, columns = ['Y'])
#concatena em um mesmo dataframe os dois dataframes anteriores
my_data = pd.concat([x_df, y_df], axis = 1)
#teremos uma feature só, e é numérica
feat_cols = [tf.feature_column.numeric_column('x', shape=[1])]
#cria o estimador
estimator = tf.estimator.LinearRegressor(feature_columns = feat_cols)
#importa o train_test_split
from sklearn.model_selection import train_test_split
#separa 30% da base para teste e 70% para treinar a rede
x_train, x_eval, y_train, y_eval = train_test_split(x_data, y_true, test_size = 0.3, random_state = 101)
 
# é preciso ter uma função de entrada(feed e indicador de tamanho de lote)
input_func = tf.estimator.inputs.numpy_input_fn({'x': x_train }, y_train, batch_size = 8, num_epochs = None, shuffle = True)

# Função de entrada dos dados de treinamento
# a razão do shuffle false, é que vamos usar essa função de entrada para avaliar em relação 
# a uma função de entrada de teste.
# função de entrada dos dados de treinamento
train_input_func = tf.estimator.inputs.numpy_input_fn({'x': x_train }, y_train, batch_size = 8, num_epochs = 1000, shuffle = False)
# função de entrada dos dados de teste
eval_input_func = tf.estimator.inputs.numpy_input_fn({'x': x_eval }, y_eval, batch_size = 8, num_epochs = 1000, shuffle = False)
# treina o estimador.
estimator.train(input_fn = input_func, steps = 1000)
# obtém algumas métricas de avaliação
train_metrics = estimator.evaluate(input_fn = train_input_func, steps = 1000)
# avalia a métrica
eval_metrics = estimator.evaluate(input_fn = eval_input_func, steps = 1000)

print('MÉTRICAS DE DADOS DE TREINAMENTO')
print(train_metrics)

print('AVALIAÇÃO DAS MÉTRICAS')
print(eval_metrics)

# gerando dados novos para testar o modelo
brand_new_data = np.linspace(0, 10, 10)

input_fn_predict = tf.estimator.inputs.numpy_input_fn({'x': brand_new_data}, shuffle = False)

list(estimator.predict(input_fn = input_fn_predict))

predictions = []

for pred in estimator.predict(input_fn = input_fn_predict):
  predictions.append(pred['predictions'])

print(predictions)

my_data.sample(n = 250).plot(kind = 'scatter', x = 'X Data', y = 'Y')

my_data.sample(n = 250).plot(kind = 'scatter', x = 'X Data', y = 'Y')
plt.plot(brand_new_data, predictions, 'r*')