Aula 14 – Tensor Flow – Redes Neurais – Regressão Linear exemplo 02

More videos
   

Aula 14 – Tensor Flow – Redes Neurais – Regressão Linear exemplo 02

Voltar para página principal do blog

Todas as aulas desse curso

Aula 13                      Aula 15

Meu github:

https://github.com/toticavalcanti

Documentação oficial do TensorFlow:

https://www.tensorflow.org/

Link para o notebook da aula:

notebook-da-aula

Python com Tensorflow

Python com Tensorflow

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

https://digitalinnovation.one/

Link do código fluente no Pinterest

Aproveito para deixar meus link de afiliados:

Hostinger

Digital Ocean

One.com

Toti:

https://www.youtube.com/channel/UCUEtjLuDpcOvR3mIUr-viOA

Backing track / Play-along:

https://www.youtube.com/channel/UCT3TryVMqTqYBjf5g5WAHfA

Código Fluente

https://www.youtube.com/channel/UCgn-O-88XBAwdG9gUWkkb0w

Putz!

https://www.youtube.com/channel/UCZXop2-CECwyFYmHbhnAkAw

Fiquem a vontade para me adicionar ao linkedin.

Aula 14 – Tensor Flow – Redes Neurais – Regressão Linear exemplo 02

Vamos a mais um exemplo, dessa vez um exemplo de regressão mais realístico.

O propósito do TensorFlow é tentar resolver problemas que os típicos algoritmos de aprendizado de máquina não conseguem resolver.

Já existem muitos algoritmos de aprendizado de máquina que podem realizar tarefas de regressão e classificação.

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.

Por essa aula é só, nos vemos na próxima, \o/ e até lá.

Link para o notebook da aula:

notebook-da-aula

Voltar para página principal do blog

Todas as aulas desse curso

Aula 13                      Aula 15

Meu github:

https://github.com/toticavalcanti

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Novamente deixo meus link de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado, até a próxima e bons estudos. 😉

 

About The Author
-

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>