No código a seguir, o x vai ficar guardando o lugar de uma matriz de floats, no formato de None linhas, porque não se sabe exatamente quantos registros teremos e 10 features, ou seja, 10 colunas.

o W são os pesos, criados aleatoriamente em uma distribuição normal, em uma matriz 10 por 3.

O b uma matriz de 1 linha e 3 colunas.

Em seguida o xW vai guardar o resultado da multiplicação da matriz x pela W.

E z da adição de xW e b.

Ao a atribuímos a função sigmoid do tensorflow.

Depois inicializamos tudo isso.

Em seguida criamos a sessão para executar e receber o resultado em layer_out.

Resultado: [[0.9794851 0.6196158 0.38397646]]

Números entre 0 e 1, porque usamos a função de ativação Sigmoid.

Função sigmoide

Código


import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
n_features = 10
n_dense_neurons = 3
# O segundo parâmetro de placeholder é o formato, Onde tem o None, 
# são os registros, ou seja, as linhas e n_features são as colunas.
x = tf.placeholder(tf.float32, (None, n_features))
W = tf.Variable(tf.random_normal([n_features, n_dense_neurons]))
b = tf.Variable(tf.ones([n_dense_neurons]))
xW = tf.matmul(x, W)
z = tf.add(xW, b)
#função de ativação
a = tf.sigmoid(z)
init = tf.global_variables_initializer()
with tf.Session() as sess:
  sess.run(init)
  layer_out = sess.run(a, feed_dict={x: np.random.random([1, n_features])})
#Resultado, números entre 0 e 1, porque estamos usando a função de ativação Sigmoid
print(layer_out)

A execução aconteceu uma vez

Mas, a execução de uma rede neural tem que voltar e fazer o backpropagation ajustando os pesos e os vieses baseado em uma função de custo.

Os valores de W e b devem sempre ser ajustado.

Para esse exemplo, vamos gerar dados distribuídos de forma linear, para nossa rede treinar e achar a equação que melhor explica a distribuição dos dados, ou seja, que melhor acompanha os dados.

No final, vamos plotar uma reta vermelhar que acompanha os pontos preditos pela equação que a rede entregou como saída.


x_data = np.linspace(0, 10, 10) + np.random.uniform(-1.5, 1.5, 10)
y_label = np.linspace(0, 10, 10) + np.random.uniform(-1.5, 1.5, 10)
import matplotlib .pyplot as plt
%matplotlib inline
plt.plot(x_data, y_label, '*')

m = tf.Variable(0.35)
b = tf.Variable(0.19)

error = 0
for x, y in zip(x_data, y_label):
  y_hat = m * x + b
  error += (y - y_hat) ** 2

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)
  training_steps = 1
  for i in range(training_steps):
    sess.run(train)
  final_slope, final_intercept = sess.run([m, b])

x_test = np.linspace(-1, 11, 10)
# y = mx + b
y_pred_plot = final_slope * x_test + final_intercept

plt.plot(x_test, y_pred_plot, 'red')
plt.plot(x_data, y_label, '*')