Já tarefas como: classificação de imagem, análise de séries temporais, entendimento de linguagem natural, etc. são problemas realmente difíceis de resolver sem o uso de uma rede neural profunda ou especializada.

Batch

No exemplo vamos gerar artificialmente uma base com 1000000 de amostras com o numpy, em uma distribuição linear usando o linspace.

O problema é que você não pode simplesmente alimentar um milhão de pontos em sua rede neural de uma só vez.

Então, para alimentar a rede neural com esse dados, temos que separar em lotes e enviar aos poucos para o processamento no treinamento da rede.

Para o nosso exemplo, vamos definir um tamanho de lote (batch size) de 8.

Não há uma resposta certa ou errada para tamanhos de lotes, certos tamanhos de batch dependem realmente de seus dados, da quantidade deles.

Código


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

x_data = np.linspace(0.0, 10.0, 1000000)
noise = np.random.randn(len(x_data))
print(x_data)
print(noise)
print(len(noise))

y_true = (0.5 * x_data) + 5 + noise
#Criando os dados
x_df = pd.DataFrame(data = x_data, columns = ['X Data'])
y_df = pd.DataFrame(data = y_true, columns = ['Y'])
print(x_df.head())

my_data = pd.concat([x_df, y_df], axis = 1)

print(my_data.head())
my_data.sample(n = 5)

my_data.sample(n = 250).plot(kind = 'scatter', x = 'X Data', y = "Y")
batch_size = 8
m = tf.Variable(0.09)
b = tf.Variable(0.39)

xph = tf.placeholder(tf.float32, [batch_size])
yph = tf.placeholder(tf.float32, [batch_size])

y_model = m * xph + b

error = tf.reduce_sum(tf.square(yph - y_model)) #y_model tem os valores previstos

optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.001)

train = optimizer.minimize(error)

init = tf.global_variables_initializer()with tf.Session() as sess:
  sess.run(init)
  batches = 1000
  for i in range(batches):
    rand_ind = np.random.randint(len(x_data), size = batch_size)

    feed = {xph: x_data[rand_ind], yph: y_true[rand_ind] }

    sess.run(train, feed_dict = feed)
  
  model_m, model_b = sess.run([m, b])

print(model_m)
print(model_b)

y_hat = x_data * model_m + model_b

my_data.sample(250).plot(kind = 'scatter', x = 'X Data', y = 'Y')
plt.plot(x_data, y_hat, 'r')

Explicação do código

Criamos a distribuição linear com o linspace do numpy, que é a nossa base de dados criada artificialmente com números variando entre 0.0 e 10.0 em uma amostragem de 1.000.000 de pontos.

Adicionamos algum ruído pra que a base não fique bem certinha linearmente, queremos uma base com distribuição em tendência linear, mas, não absolutamente linear, por isso, a inserção de ruído.

O y_true, é o gabarito, colocamos o m = 0.5 e o b = 5 na equação linear y = mx + b

Depois de criar os dados, colocamos em dataframes pandas, o x_df e o y_df, para melhor manipular os dados.

Estabelecemos o tamanho de batch em 8.

Criamos duas variáveis iniciais para m e b.

São os valores de m e b que a rede precisa prever, e como criamos os dados utilizando os valores m = 0.5 e b = 5.0, então, se a rede funcionar corretamente, ela deverá prever um valor próximo de 0.5 para m e próximo a 5.0 o valor de b.