Em 1958 Frank Rosenblatt deu vida a perceptron de uma camada, também conhecida como perceptron simples, a vovozinha das redes neurais, sendo o modelo mais simplista de uma rede neural, não podemos esperar que ela faça malabarismos, mas ainda assim,  tem seu charme. Este modelo funciona como um classificador linear, mas o que é um classificador linear? Imagine que você está criando um jogo, onde cada soldado precisa tomar decisões com base em informações que recebe, e assim deve decidir se deve atacar ou não. Pois é, parece um “if e else” sofistificado e cheio de operações matemáticas. Nesse contexto, as entradas definem a saída. Essas entradas são propriedades que definem o comportamento do soldado, como a distância euclidiana, quantidade de munições, entre outros atributos. Porém, “Perceptronauta”, para começar de maneira simples, irei introduzir um perceptron usando as portas AND e XOR, e descobrir uns segredinhos. É como ensinar a vovó a distinguir entre chá e café: básico, mas essencial para construir conhecimentos mais complexos! Vamos nessa então!

Estrutura do Perceptron 

A estrutura de uma rede neural é simples, mas os processos por trás dela são como um quebra-cabeça. Os neurônios são as unidades básicas que processam informações. Eles são inspirados nos neurônios biológicos, e têm a seguinte estrutura básica, veja a Figura 1.0 e a descrição a seguir: 

Rede Neural

Figura 1.0 – Redes Neurais

  • Entradas (Inputs): Neurônios recebem múltiplas entradas, cada uma com um peso;
  • Pesos (Weights): Ajustam a força de cada entrada para minimizar erros. Anote num caderninho essa informação;
  • Função de Soma (Summation Function): Calcula a soma ponderada das entradas;
  • Função de Ativação (Activation Function): Após calcular a soma ponderada, o neurônio aplica uma função de ativação.

Batalha das Separabilidades: Lineares vs. Não Lineares

Lembra do segredinho que te falei no começo deste post? Os problemas podem ser linearmente separáveis ou não linearmente separáveis: 

  • Linearmente Separáveis: Esses são os problemas linearmente separáveis! Uma única linha reta é tudo o que precisamos para dividir as classes. Um exemplo clássico é a Porta AND, onde tudo se encaixa direitinho com uma linha reta bem no meio.
  • Não Linearmente Separáveis: Agora, as coisas ficam mais caóticas com os problemas não linearmente separáveis. Aqui, uma única linha reta não resolve a bagunça. Pense na Porta XOR, onde uma simples linha reta falha miseravelmente. Para vencer essa batalha, precisamos de armas mais sofisticadas: redes neurais mais complexas! As MLPs (Multi-Layer Perceptrons) entram em cena, capazes de capturar todas as nuances e relações não lineares nos dados, garantindo a vitória no campo de batalha da separabilidade. 

Operadores Lógicos: Os Super-Herois da Computação

Imagine um mundo onde pequenos herois trabalham incansavelmente para tomar decisões e resolver problemas. Esses herois são os operadores lógicos, cada um com suas habilidades especiais para determinar resultados baseados em condições específicas. Vamos conhecer dois desses super-herois da computação para o nosso estudo de caso.

A Super And

Imagine que você está jogando um jogo de aventura. Para abrir o Baú Mágica do tesouro, você precisa de duas chaves especiais: a Chave de Ouro e a Chave de Prata. Só quando você tem ambas as chaves, a porta se abre. Vamos ver isso na prática com a tabela verdade da porta AND:

Chave de Ouro (Entrada 1) Chave de Prata (Entrada 2) Baú (Saída)
0 0 0 (0,0 ) O baú do tesouro não abre. 
0 1 0 (0,1 ) O baú permanece fechado
1 0 0 (1,0 ) O baú permanece fechado
1 1 1 (1,1) O baú se abre e você encontra o tesouro!

Lembra-se que eu te contei? As entradas (chaves de ouro e chave de prata) são as propriedades da rede, lembra? e a saída  o que queremos. Veja o gráfico da Figura 2.0, o que você vê? 

Porta And

Figura 2.0 – Operador And

Veja que temos os dados linearmente separáveis, isso significa que a perceptron simples pode aprender a classificação correta e convergir para as saídas desejadas.

  • Os pontos vermelhos representam as entradas com saída 0;
  • Os pontos azuis representam as entradas com saída 1;
  • A linha verde tracejada representa a linha de separação linear.

A Super XOR

Chave de Ouro (Entrada 1) Chave de Prata (Entrada 2) Baú (Saída)
0 0 0 (0,0 ) O baú do tesouro não abre. 
0 1 1 (0,1 ) O baú abre
1 0 1 (1,0 ) O baú abre
1 1 0 (1,1)  O baú do tesouro não abre. 

A porta XOR não é linearmente separável. Não existe uma linha reta que possa separar as saídas 0 das saídas 1 no plano de entrada. Veja a Figura 3.0: 

Porta XOR

Figura 3.0 – Operador Xor

Você consegue traçar uma linha reta para separar?

  • Os pontos vermelhos representam as entradas com saída 0.
  • Os pontos azuis representam as entradas com saída 1.

Como podemos ver, não é possível desenhar uma única linha reta que separa os pontos das duas classes (saídas 0 e 1). Portanto, a porta XOR não é linearmente separável para a perceptron de uma camada.

O Cérebro do Perceptron: Decodificando os Cálculos e Ajustes

1. Previsão (Predict)

Para prever a saída, o perceptron calcula uma soma ponderada das entradas multiplicadas pelos pesos correspondentes e, em seguida, aplica a função de ativação.

Soma Ponderada:

Sum

Função de Ativação (Step Function):

Ajuste dos Pesos (Train)

Durante o treinamento, o perceptron ajusta os pesos para minimizar o erro entre a previsão e o rótulo (label) desejado.

Erro:  Indica a discrepância entre a previsão do perceptron e o valor da saída (desejada). Esse erro é utilizado para ajustar os pesos do perceptron, de modo que futuras previsões sejam mais precisas.

Error

Ajuste dos Pesos

Vamos Explorar os Dados do Operador Lógico AND?

Configurações Iniciais

Pesos Inicializados: weights=[0.2, -0.1]

  • Descrição: Valores atribuídos a cada entrada do perceptron que determinam a influência dessas entradas na saída final. Inicializar os pesos significa atribuir valores iniciais a eles antes do início do treinamento.
  • Importância: Escolher pesos iniciais aleatórios pequenos ajuda a quebrar a simetria e a permitir que o modelo aprenda adequadamente durante o treinamento.

Taxa de Aprendizado

Taxa de Aprendizado: learningRate=0.01

  • Descrição: Hiperparâmetro que controla a quantidade de ajuste nos pesos em cada iteração do treinamento.
  • Importância: Um valor de 0.01 ajusta os pesos lentamente, garantindo que o modelo converja de forma estável. Valores muito altos podem impedir a convergência, enquanto valores muito baixos tornam o treinamento lento.

Dados de Treinamento

Dados de Treinamento: trainingInputs = [{0,0}, {0,1}, {1,0}, {1,1}]

  • Descrição: Conjuntos de entradas usadas pelo perceptron para aprender. Cada par {x1, x2} representa uma combinação de valores de entrada para treinar o modelo.
  • Importância: Fornecem exemplos a partir dos quais o perceptron aprenderá a classificar ou prever a saída correta. Exemplos simples ajudam a demonstrar a lógica do perceptron.

Labels

Labels: labels= [0, 0, 0, 1]

  • Descrição: Valores esperados de saída para cada conjunto de entradas nos dados de treinamento. Representam a “verdade” que o perceptron deve aprender a prever.
  • Importância: Usados para calcular o erro durante o treinamento. O perceptron ajusta seus pesos para minimizar a diferença entre suas previsões e esses valores de saída esperados.

Época

Época: 10

  • Descrição: Um ciclo completo através de todo o conjunto de dados de treinamento. O número de épocas especifica quantas vezes o modelo passará por todo o conjunto de dados durante o treinamento.
  • Importância: Treinar o modelo por múltiplas épocas permite ajustes repetidos dos pesos, melhorando a precisão. Mais épocas geralmente resultam em um modelo mais bem treinado, mas excesso pode causar overfitting.
Época Iteração Entradas Pesos Iniciais Soma Ponderada Previsão Erro Ajuste dos Pesos Novos Pesos 
1 1 (0,0) [0.2, -0.1] 0*0.2 + 0* (-0.1) 1 -1 [0.2 + (-1)*0*0.01, -0.1 + (-1)*0*0.01] [0.2, -0.1]
1 2 (0,1) [0.2, -0.1] 0*0.2 + 0* (-0.1) 0 0 [0.2 + 0*0*0.01, -0.1 + 0*1*0.01] [0.2, -0.1]
1 3 (1, 0) [0.2, -0.1] 0.2*1 + (-0.1)*0 = 0.2 1 -1 [0.2 + (-1)*1*0.01, -0.1 + (-1)*0*0.01] [0.19, -0.1]
1 4 (1, 1) [0.19, -0.1] 0.19*1 + (-0.1)*1 = 0.09 1 0 [0.19 + 0*1*0.01, -0.1 + 0*1*0.01] [0.19, -0.1]

Você irá fazer essa iteração até que todos os erros fiquem igual a zero. Entretanto note, que a próxima rodada a época será 2, e consequentemente os pesos iniciais serão substituídos pelos novos pesos. 

Conclusão

Distinguir entre problemas linearmente separáveis e não separáveis ajuda a escolher o modelo adequado para o problemas. Problemas complexos e realistas, como o de abrir o Baú Mágico do Tesouro com a lógica XOR, geralmente exigem modelos não lineares mais avançados para alcançar uma performance aceitável. No caso da porta XOR, a complexidade adicional requer um modelo mais sofisticado, como uma rede neural de múltiplas camadas, para resolver o problema de forma eficaz.