Desenvolvimento

8 mai, 2019

Redes neurais roots – Parte 03: show me the code

100 visualizações
Publicidade

Como já explicado na primeira e segunda parte do artigo sobre redes neurais, vamos implementar em Python o que seria equivalente a um (1) neurônio.

Detalhando um pouco nosso problema

Somos um e-commerce e temos uma base histórica do comportamento do nosso cliente dentro da nossa plataforma e também temos a informação sobre o nosso cliente ter comprado ou não um produto.

Vamos dar uma olhada nesses dados:

Temos aqui duas informações sobre nossos usuários, onde cada linha é um “comprador” e cada coluna corresponde às seguintes situações:

  • Se ele entrou na página do produto
  • Se entrou na página de carrinho
  • Se comprou

Note que temos uma padrão ali, onde dependendo das ações do usuário, eu sou capaz de dizer se ele vai comprar ou não algo na loja!

Vamos codar isso!

Começaremos definindo alguns parâmetros para a nossa rede.

Observação: não usaremos o valor e bias aqui, pois ele é opcional (mas muito importante), e para simplificar o exemplo, vamos sem ele, apenas para construir o mindset de como funciona um neurônio de fato. Veremos mais sobre quando formos trabalhar com múltiplos neurônios.

import numpy as np

entradas = np.array([[0,0],[0,1], [1,0], [1,1]])
saidas = np.array([0,1,1,1])
pesos = np.array([0.0, 0.0])
taxaAprendizagem = 0.1

Importamos a biblioteca numpy para manipular de forma fácil algumas listas/matrizes, definimos nosso dados de entrada (x) e nossos dados de saída (y), onde x = comportamento do usuário, que é o que eu vou usar para saber se ele vai comprar ou não, e y = dados de saída de pessoas que já passaram pela nossa plataforma e que nós vamos usar para verificar se nossos dados de classificação estão corretos.

Definimos nossos pesos para cada característica que vai entrar dentro do nosso neurônio e também escolhemos uma taxa de aprendizado que será responsável pela velocidade de convergência do nosso neurônio. Ou seja, o quão rápido ele treina.

Feito isso, podemos começar a codificar o nosso neurônio de fato. Vamos começar pela nossa função de ativação, que é a ultima etapa do nosso neurônio.

def stepFunction(soma):
    if (soma >= 1):
        return 1
    return 0

Como explicado na primeira parte do nosso artigo sobre redes neurais (ou segunda), nós usamos uma função de ativação para converter o resultado da nossa regressão (ax+b ou wx+b) em uma saída binária ou percentual (0.0, 0.1, 0.2…0.9).

Nesse caso vamos usar a função step, que dada uma somatória das entradas pelos pesos, ele nos dá um valor de 0 ou 1.

Vamos agora codificar o próprio neurônio.

def calculaSaida(registro):
    #multiplica a matriz "registro" 
    #pela matriz "pesos" e depois soma tudo
    soma = registro.dot(pesos)
    return stepFunction(soma)

Note que estamos usando uma função chamada “.dot()” dessa variavel registro. Basicamente vamos receber um array do numpy como parâmetro no método calculaSaida() e todo array numpy tem o método “.dot()”, que recebe um outro array ou matriz e é responsável pela multiplicação desses dois arrays/matrizes. No fim ele retorna a soma de todo mundo.

Essa soma nós passamos para a função Step que nos retorna um valor de 0 ou 1, onde 0 significa que nosso cliente não vai comprar nosso produto e 1 significa que nosso usuário irá comprar.

Porém, para que nossas classificação saiam corretas, antes precisamos dos nossos pesos corretos.

Como vamos achar esses pesos? Falamos disso no artigo sobre treinamento – dê uma conferida.

def treinar():
    erroTotal = None
    #enquanto o erro não for igual à 0 (zero)
    while (erroTotal != 0):
        erroTotal = 0
        #faça o ajuste dos pesos para cada uma das nossas classes
        for i in range(len(saidas)):
            #faz uma classificação
            saidaCalculada = calculaSaida(np.asarray(entradas[i]))
            #Calcula o erro da nossa classificação
            erro = saidas[i] - saidaCalculada
            erroTotal += erro
            #para cada um dos pesos: atualize o valor dele com base no nosso erro
            for j in range(len(pesos)):
                pesos[j] = pesos[j] + (taxaAprendizagem * entradas[i][j] * erro)
                print('Peso atualizado: ' + str(pesos[j]))
        print('Total de erros: ' + str(erroTotal))

Depois de termos nossos pesos ajustados, é só fazer a classificação dos seus usuários.

treinar()
print('Rede neural treinada')
print(calculaSaida(entradas[0]))
print(calculaSaida(entradas[1]))
print(calculaSaida(entradas[2]))
print(calculaSaida(entradas[3]))

Você pode encontrar o código completo aqui.

No próximo artigos falaremos sobre múltiplos neurônios conectados.

Obrigado!