Se caíram aqui neste artigo é porque provavelmente estão no meio (ou estão prestes a iniciar) de um trabalho acadêmico sobre inteligência artificial, mais precisamente, a implementação do Neurônio de Rosenblatt em uma planilha eletrônica (caso tenha sido solicitado código computacional, recomendo fortemente que faça em planilha primeiramente). Antes de escrevê-lo, pesquisei na internet e vi vários artigos com explicações muito boas e vários deles usando o exemplo da porta AND (relaxem – não vou usar o exemplo da porta AND). Sendo assim senti que precisava contribuir de alguma forma e decidi escrever a minha versão sobre o tal problema.
Basicamente, Frank Rosenblatt (psicólogo estadunidense) ao tentar imitar o funcionamento do cérebro humano, acabou criando um neurônio artifical (o tipo mais simples), conhecido por Perceptron, na década de 1950.
Quero usar o Perceptron para uma coisa bem simples: exibir, com base em uma determinada temperatura inserida, se saio de camiseta ou de blusa. Apesar de parecer tosco, serve bem para ilustrar.
Simplesmente, o neurônio deve escrever “Camiseta” se a temperatura inserida for igual ou maior a 20 graus Celsius ou “Blusa” se menor que 20 graus Celsius.
Neste exemplo vou usar a planilha eletrônica Libre Office Calc 6.3.6.2. Acredito que para o pacote MS Office Excel, os comandos sejam exatamente os mesmos.
Primeiramente, com uma explicação genérica
Atentem-se em criar duas abas na planilha. Uma de nome “treinamento”, onde vai ocorrer o treinamento propriamente dito e outra de nome “perceptron”, que será utilizada para enfeitar.
Bias: espécie de ajuste fino.T.A.(taxa de aprendizagem): aqui é definida a velocidade de aprendizagem do neurônio.X1: entrada do dado um.X2: entrada do dado dois.S: saída desejada.W1: é o valor (peso) associado ao “X1”. Não há regra e pode ser escolhidos valores aleatórios próximos a “1”.W2: é o valor (peso) associado ao “X2”. Não há regra e pode ser escolhidos valores aleatórios próximos a “1”.d(saída intermediária): aqui é demonstrado o quanto de estímulo as entradas geraram.a(função de ativação): aqui é definido se o estímulo recebido de “d” é o suficiente ou não para executar a ativação.p(predição): deve bater com a saída (S) desejada. Ex.: se as saídas desejadas forem “0” ou “1”, não faz sentido que a função “p” escreva “2” ou “3”.e(erro): faz a quantificação do erro. Ou seja, subtrai-se a saída desejada (S) da predição (p).D1(Delta 1): o Delta 1 é gerado a partir da multiplicação entre a taxa de aprendizagem (T.A.), a entrada 1 (X1) e o erro (e). Aqui se inicia o processo de ajuste do peso (W) para a próxima rodada; ou melhor, próxima linha da planilha eletrônica. Como neste momento está sendo calculado o Delta 1, logo deve ser usado o X1.D2(Delta 2): o Delta 2 é gerado a partir da multiplicação entre a taxa de aprendizagem (T.A.), a entrada 2 (X2) e o erro (e). Aqui se inicia o processo de ajuste do peso (W) para a próxima rodada; ou melhor, próxima linha da planilha eletrônica. Como neste momento está sendo calculado o Delta 2, logo deve ser usado o X2.nW1(novo peso W1): Para gerar o novo peso basta somar o peso antigo (W1) com o delta (D1).nW2(novo peso W2): Para gerar o novo peso basta somar o peso antigo (W2) com o delta (D2).
Informação importante: se seu neurônio possuir quatro entradas (X1, X2, X3 e X4), deve respectivamente, possuir quatro pesos (W1, W2, W3 e W4), quatro deltas (D1, D2, D3 e D4) e quatro pesos novos (nW1, nW2, nW3 e nW4).
Entrando de cabeça (isso foi um trocadilho?)
Para o Bias, não existe regra. Decidi utilizar o valor “-1”. Quanto ao “T.A.”, reforço o que tinha escrito anteriormente: é a velocidade de aprendizagem do neurônio. Neste caso coloquei em 1% (0,01). É uma taxa muito boa. Taxas muito altas podem levar a um aprendizado não muito bom.
Observem que em “X1” eu coloquei “2” e em “X2” foi adicionado “0”. Ou seja, estes valores estão representando 20 graus Celsius (quero que o valor base seja 20). Em “S” adicionei o valor “1”. Em outras palavras quero que o neurônio entenda que estou “amarrando” uma saída “1” à temperatura 20. Para o peso “W1” escolhi o valor “0,2” e para peso “W2” escolhi o valor “0,4”. Nada impede vocês de escolherem outros valores para os pesos “W1” e “W2”.
Para a saída intermediária, ou melhor “d”, utiliza-se seguinte fórmula: =(A6*D6)+(B6*E6)+(B$2). Observem que utilizei o sinal “$” antes do “2”. Neste caso estou informando para a planilha que quero fixar a linha “2”. Ou seja, sempre será apontado para um único Bias. Aqui é demonstrado o quanto de estímulo as entradas geraram.
Para a função de ativação, ou melhor “a”, utiliza-se da seguinte fórmula: =SE(F6>=0;1;-1). Se a saída intermediária retornar um valor maior ou igual a “0”, escreva o valor “1”; caso contrário escreva “-1”. Estamos usando a função do tipo degrau; para false, falso ou desligado é utilizado “-1”; para true, verdadeiro ou ligado, é utilizado “+1”; aqui é definido se o estímulo recebido de “d” é o suficiente ou não para executar a ativação.
Para a função predição, ou melhor “p”, utiliza-se da seguinte fórmula: =SE(G6=1;1;0). Deve bater com a saída (S) desejada. Ex.: se as saídas desejadas forem “0” ou “1”, não faz sentido que a função p escreva “2” ou “3”. Ou seja, a função “p” (neste caso) deve escrever “0” ou “1” para bater com as saídas das temperaturas que são/serão “1” e “0”.
Para o erro, ou melhor “e”, utiliza-se da seguinte fórmula: =C6-H6. Aqui estamos fazendo a quantificação do erro. Ou seja, subtraímos a saída desejada “S” da predição “p”. Toda vez que houver um erro, o valor desta coluna deverá ser diferente de “0”. Se tiver um erro e for igual a “0”, volte e revise o passo anterior.
Para o delta 1, ou melhor “D1”, utiliza-se da seguinte fórmula: =B$3*A6*I6. O delta 1 é gerado a partir da multiplicação entre a taxa de aprendizagem (T.A.), a entrada 1 (X1) e o erro (e). Aqui se inicia o processo de ajuste do peso (W) para a próxima rodada; ou melhor, a próxima linha da planilha eletrônica. Como neste momento está sendo calculado o Delta 1, logo deve ser usado o “X1”.
Para o delta 2, ou melhor D2, utiliza-se da seguinte fórmula: =B$3*B6*I6. o Delta 2 é gerado a partir da multiplicação entre a taxa de aprendizagem (T.A), a entrada 2 (X2) e o erro (e). Aqui se inicia o processo de ajuste do peso (W) para a próxima rodada; ou melhor, próxima linha da planilha eletrônica. Como neste momento está sendo calculado o Delta 2, logo deve ser usado o “X2”. Observem que tanto para “D1”, quanto para “D2”, foi também fixada a linha “3” com o caractere “$”. Ou seja, sempre será utilizado a mesma taxa de aprendizagem para este exemplo.
Para o novo peso 1, ou melhor “nW1”, utiliza-se da seguinte fórmula: =D6+J6. Ou seja, é somado o “W1” com “D1”.
Para o novo peso 2, ou melhor “nW2”, utiliza-se da seguinte fórmula: =E6+K6. Ou seja, é somado o “W1” com “D1”.
A linha 6 foi construída apenas para montar o treinamento e demostrar as fórmulas. Se observarem verão que deixei ela na cor vermelha). O treinamento de fato vai começar a partir da linha 7. Vou usar duas temperaturas acima de 20 amarradas a uma saída “1” e três temperaturas menores que 20 amarradas a uma saída “0”. Notem que eu repeti a temperatura 20 (células A7 e B7) com a saída 1 (célula C7). Neste momento o peso “W1” da linha 7 (D7) aponta para o novo peso 1 da linha 6 (faz referência a célula L6).
Aqui também segue o mesmo raciocício: o peso “W2” da linha 7 aponta para o novo peso 2 da linha 6 (faz referência a célula M6).
O restante pode ser copiado. Selecione de F6 a M6. Copie e cole na célula F7.
Irão notar que a linha 7 ficou completa.
Na linha 8 estou amarrando para a temperatura 25, uma saída 1; na linha 9 também estou amarrando para a temperatura 30, uma saída 1; na linha 10 amarro para a temperatura 15, uma saída 0; na linha 11, amarro para a temperatura 10, uma saída 0; por fim, na linha 12 amarro para a temperatura 05, uma saída 0. Ou seja, eu tenho três temperaturas com saídas “1” e três temperaturas com saídas “0”. Acredito que é o suficiente para treinar o neurônio. Nada impede de usar duas temperaturas acima e duas abaixo ou dez acima e dez abaixo.
Selecione, da célula D7 até a M7 e copie (Ctrl + C). Agora selecione da célula D8 até a célula D12 e cole (Ctrl + V).
Se tudo deu certo, deve estar igual a imagem acima.
Agora é que acontece a mágica
Selecione da célula A7 até a M12 e copie. Neste passo observem que deixei os textos que estão sendo copiados na cor preta (apenas para destacar o que de fato será usado para o treinamento).
Clique na célula A13 e cole.
Selecione da célula A13 até a M18 e copie.
Clique na célula A19 e cole.
Selecione da célula A19 até a M24 e copie. Clique na célula A25 e cole.
.
.
.
Faça isso várias vezes (obviamente ascendendo as células) até notar o seguinte padrão: a linha “I” ou coluna “e” (erro) mostra somente 0 (não estão acontecendo erros). Observem que no treinamento do exemplo, decidi parar na linha 96. Se atentem as colunas D (W1) e E (W2) que obtive os pesos “0,5” e “0,05” respectivamente. Estes são os pesos que nós precisamos.
Volte para a parte de cima da planilha, selecione da célula A5 até a M6 e copie.
Clique na linha A98 e cole. Como estão aprendendo, tentem fazer exatamente igual a planilha do artigo.
Digite os pesos “W1” e “W2” obtidos no treinamento (0,5 e 0,05) nas células D99 e E99. Agora sim, o meu neurônio pronto e treinado está sendo representando apenas pelas linhas 98 e 99.
Deixe a aba “perceptron” exatamente como na imagem acima.
Volte para a aba “treinamento”, clique na célula A99 e digite um sinal de igual (=).
Volte para a aba “perceptron” e clique na célula A3 e dê enter. Ou seja, tudo o que for digitado na célula A3 da aba “perceptron” será automaticamente inserido na célula A99 da aba “treinamento”.
Volte para a aba “treinamento”, clique na célula B99 e digite um sinal de igual (=).
Volte para a aba “perceptron” e clique na célula B3 e dê enter. Ou seja, tudo o que for digitado na célula B3 da aba “perceptron” será automaticamente inserido na célula B99 da aba “treinamento”.
Na célula C3 da aba “perceptron” digite a seguinte fórmula: =SE($treinamento.I99=0;"Camiseta";"Blusa").
Explicação: as temperaturas iguais ou maiores que 20 foram amarradas a “1”; as temperaturas menores que 20 foram amarradas a “0”. A linha que estou usando para representar o neurônio treinado, tem “1” na saída (S). Ou seja, sempre que forem inseridas temperaturas iguais ou maiores que 20, a coluna erro permenecerá em “0” (não teve erro). Sempre que foram inseridas temperaturas menores que 20, a coluna erro mostra “1”. Logo a fórmula =SE($treinamento.I99=0;"Camiseta";"Blusa") escreve “Camiseta” se for “0” na célula I99 da aba treinamento ou escreve “Blusa” se for “1” na célula I99 da aba treinamento.
Para 20 graus, o neurônio me informa que devo usar camiseta.
Para 55 graus, o neurônio me informa que devo usar camiseta. (vamos lá gente, é só uma ilustração)
Para 99 graus, o neurônio me informa que devo usar camiseta.
Para 19 graus, o neurônio me informa que devo usar blusa.
Para 10 graus, o neurônio me informa que devo usar blusa.
Para 1 grau, o neurônio me informa que devo usar blusa.
Vejam por este ângulo (rsrs) o que acontece quando é inserida a temperatura 01 com a saída “S” 1; ocorre um erro (1), cujo é mostrado na célula I99.
Para ilustrar e tentar deixar mais completa a explicação, desenvolvi um código computacional na linguagem Java:
public class Principal {
public static void main(String[] args) {
double bias = -1;
double ta = 0.01;
byte x1 = 0;
byte x2 = 0;
int s = 0;
double w1 = 0;
double w2 = 0;
double d = 0;
byte a = 0;
int p = 0;
int e = 0;
double d1 = 0;
double d2 = 0;
double nw1 = 0;
double nw2 = 0;
boolean loop = true;
int vetor[] = new int[1000];
int cont = 0;
int padrao = 0;
// linha 1 (head)
x1 = 2;
int x1_origem = x1;
x2 = 0;
int x2_origem = x2;
s = 1;
int s_origem = s;
w1 = 0.2;
w2 = 0.4;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
while (loop) {
// linha 2 (body)
x1 = 2;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 3 (body)
x1 = 2;
x2 = 5;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 4 (body)
x1 = 3;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 5 (body)
x1 = 1;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 6 (body)
x1 = 1;
x2 = 0;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 7 (body)
x1 = 0;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a == 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
if (cont >= 500) {
for (int i = 0; i < 499; i++) {
if (vetor[i] == 0) {
padrao++;
} else {
padrao = 0;
}
if (padrao > 15) {
loop = false;
}
}
System.out.printf("Bias: %.0f\n", bias);
System.out.printf("Taxa de aprendizado: %.2f\n", ta);
System.out.println("X1: " + x1_origem);
System.out.println("X2: " + x2_origem);
System.out.println("S: " + s_origem);
System.out.printf("W1 encontrado: %.2f\n", w1);
System.out.printf("W2 encontrado: %.2f\n", w2);
}
}
}
}
Saída
Bias: -1 Taxa de aprendizado: 0,01 X1: 2 X2: 0 S: 1 W1 encontrado: 0,50 W2 encontrado: 0,05
Também observem o código computacional em Python:
bias = -1
ta = 0.01
x1 = 0
x2 = 0
s = 0
w1 = 0
w2 = 0
d = 0
a = 0
p = 0
e = 0
d1 = 0
d2 = 0
nw1 = 0
nw2 = 0
loop = True
vetor = []
cont = 0
padrao = 0
i = 0
# linha 1 (head)
x1 = 2
x1_origem = x1
x2 = 0
x2_origem = x2
s = 1
s_origem = s
w1 = 0.2
w2 = 0.4
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
while loop:
# linha 2 (body)
x1 = 2
x2 = 0
s = 1
w1 = nw1
w2 = nw2
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
# linha 3 (body)
x1 = 2
x2 = 5
s = 1
w1 = nw1
w2 = nw2
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
# linha 4 (body)
x1 = 3
x2 = 0
s = 1
w1 = nw1
w2 = nw2
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
# linha 5 (body)
x1 = 1
x2 = 5
s = 0
w1 = nw1
w2 = nw2
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
# linha 6 (body)
x1 = 1
x2 = 0
s = 0
w1 = nw1
w2 = nw2
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
# linha 7 (body)
x1 = 0
x2 = 5
s = 0
w1 = nw1
w2 = nw2
d = (x1 * w1) + (x2 * w2) + bias
if d >= 0:
a = 1
else:
a = -1
if a == 1:
p = 1
else:
p = 0
e = s - p
vetor.insert(cont, e)
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
if cont >= 500:
while i < 499:
if vetor[i] == 0:
padrao = padrao + 1
else:
padrao = 0
if padrao > 15:
loop = False
i = i + 1
print('Bias:',bias)
print('Taxa de aprendizado:',ta)
print('X1:',x1_origem)
print('X2:',x2_origem)
print('S:',s_origem)
print("W1 Encontrado: {0:.2f}".format(w1))
print("W1 Encontrado: {0:.2f}".format(w2))
Saída
Bias: -1 Taxa de aprendizado: 0.01 X1: 2 X2: 0 S: 1 W1 Encontrado: 0.50 W1 Encontrado: 0.05
Também observem o código computacional em C:
#include <iostream>
int main(){
double bias = -1;
double ta = 0.01;
int x1 = 0;
int x2 = 0;
int s = 0;
double w1 = 0;
double w2 = 0;
double d = 0;
int a = 0;
int p = 0;
int e = 0;
double d1 = 0;
double d2 = 0;
double nw1 = 0;
double nw2 = 0;
bool loop = true;
int vetor[1000] = {};
int cont = 0;
int padrao = 0;
// linha 1 (head)
x1 = 2;
int x1_origem = x1;
x2 = 0;
int x2_origem = x2;
s = 1;
int s_origem = s;
w1 = 0.2;
w2 = 0.4;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
while (loop) {
// linha 2 (body)
x1 = 2;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 3 (body)
x1 = 2;
x2 = 5;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 4 (body)
x1 = 3;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 5 (body)
x1 = 1;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 6 (body)
x1 = 1;
x2 = 0;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 7 (body)
x1 = 0;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
}else {
a = -1;
}
if (a == 1) {
p = 1;
}else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
if (cont >= 500) {
for (int i = 0; i < 499; i++) {
if (vetor[i] == 0) {
padrao++;
}else {
padrao = 0;
}
if (padrao > 15) {
loop = false;
}
}
printf("Bias: %.0f\n", bias);
printf("Taxa de aprendizado: %.2f\n", ta);
printf("X1: %d\n",x1_origem);
printf("X2: %d\n",x2_origem);
printf("S: %d\n",s_origem);
printf("W1 encontrado: %.2f\n", w1);
printf("W2 encontrado: %.2f\n", w2);
}
}
system("pause");
return 0;
}
Saída
Bias: -1 Taxa de aprendizado: 0.01 X1: 2 X2: 0 S: 1 W1 encontrado: 0.50 W2 encontrado: 0.05 Pressione qualquer tecla para continuar. . .
Também observem o código computacional em VB.NET:
Imports System
Module Program
Sub Main(args As String())
Dim bias As Double = -1
Dim ta As Double = 0.01
Dim x1 As Integer = 0
Dim x2 As Integer = 0
Dim s As Integer = 0
Dim w1 As Double = 0
Dim w2 As Double = 0
Dim d As Double = 0
Dim a As Integer = 0
Dim p As Integer = 0
Dim e As Integer = 0
Dim d1 As Double = 0
Dim d2 As Double = 0
Dim nw1 As Double = 0
Dim nw2 As Double = 0
Dim ciclo As Boolean = True
Dim Vetor(1000) As Integer
Dim cont As Integer = 0
Dim padrao As Integer = 0
'linha 1 (head)'
x1 = 2
Dim x1_origem As Integer = x1
x2 = 0
Dim x2_origem As Integer = x2
s = 1
Dim s_origem As Integer = s
w1 = 0.2
w2 = 0.4
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
While ciclo
'linha 2 (body)'
x1 = 2
x2 = 0
s = 1
w1 = nw1
w2 = nw2
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
'linha 3 (body)'
x1 = 2
x2 = 5
s = 1
w1 = nw1
w2 = nw2
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
'linha 4 (body)'
x1 = 3
x2 = 0
s = 1
w1 = nw1
w2 = nw2
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
'linha 5 (body)'
x1 = 1
x2 = 5
s = 0
w1 = nw1
w2 = nw2
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
'linha 6 (body)'
x1 = 1
x2 = 0
s = 0
w1 = nw1
w2 = nw2
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
'linha 7 (body)'
x1 = 0
x2 = 5
s = 0
w1 = nw1
w2 = nw2
d = ((x1 * w1) + (x2 * w2) + bias)
If d >= 0 Then
a = 1
Else
a = -1
End If
If a = 1 Then
p = 1
Else
p = 0
End If
e = s - p
Vetor(cont) = e
cont = cont + 1
d1 = ta * x1 * e
d2 = ta * x2 * e
nw1 = w1 + d1
nw2 = w2 + d2
If cont >= 500 Then
For i As Integer = 0 To 499
If Vetor(i) = 0 Then
padrao = padrao + 1
Else
padrao = 0
End If
If padrao > 15 Then
ciclo = False
End If
Next
Console.WriteLine("Bias: {0}", bias)
Console.WriteLine("Taxa de aprendizado: {0:0.00}", ta)
Console.WriteLine("X1: {0}", x1_origem)
Console.WriteLine("X2: {0}", x2_origem)
Console.WriteLine("S: {0}", s_origem)
Console.WriteLine("W1 encontrado: {0:0.00}", w1)
Console.WriteLine("W2 encontrado: {0:0.00}", w2)
End If
End While
End Sub
End Module
Saída
Bias: -1 Taxa de aprendizado: 0,01 X1: 2 X2: 0 S: 1 W1 encontrado: 0,50 W2 encontrado: 0,05
Também observem o código computacional em C#:
namespace Projeto{
class Program{
static void Main(string[] args){
double bias = -1;
double ta = 0.01;
int x1 = 0;
int x2 = 0;
int s = 0;
double w1 = 0;
double w2 = 0;
double d = 0;
int a = 0;
int p = 0;
int e = 0;
double d1 = 0;
double d2 = 0;
double nw1 = 0;
double nw2 = 0;
bool loop = true;
int[] vetor = new int[1000];
int cont = 0;
int padrao = 0;
// linha 1 (head)
x1 = 2;
int x1_origem = x1;
x2 = 0;
int x2_origem = x2;
s = 1;
int s_origem = s;
w1 = 0.2;
w2 = 0.4;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
while (loop){
// linha 2 (body)
x1 = 2;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else
{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 3 (body)
x1 = 2;
x2 = 5;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 4 (body)
x1 = 3;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 5 (body)
x1 = 1;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 6 (body)
x1 = 1;
x2 = 0;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 7 (body)
x1 = 0;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0){
a = 1;
}else{
a = -1;
}
if (a == 1){
p = 1;
}else{
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
if (cont >= 500){
for (int i = 0; i < 499; i++){
if (vetor[i] == 0){
padrao++;
}else{
padrao = 0;
}
if (padrao > 15){
loop = false;
}
}
Console.WriteLine("Bias: {0}", bias);
Console.WriteLine("Taxa de aprendizado: {0}", ta);
Console.WriteLine("X1: {0}", x1_origem);
Console.WriteLine("X2: {0}", x2_origem);
Console.WriteLine("S: {0}", s_origem);
Console.WriteLine("W1 encontrado: {0:0.00}", w1);
Console.WriteLine("W2 encontrado: {0:0.00}", w2);
}
}
}
}
}
Saída
Bias: -1 Taxa de aprendizado: 0,01 X1: 2 X2: 0 S: 1 W1 encontrado: 0,50 W2 encontrado: 0,05
Também observem o código computacional em Javascript:
function neuronio(){
let bias = -1;
let ta = 0.01;
let x1 = 0;
let x2 = 0;
let s = 0;
let w1 = 0;
let w2 = 0;
let d = 0;
let a = 0;
let p = 0;
let e = 0;
let d1 = 0;
let d2 = 0;
let nw1 = 0;
let nw2 = 0;
let loop = true;
let vetor = [];
let cont = 0;
let padrao = 0;
// linha 1 (head)
x1 = 2;
let x1_origem = x1;
x2 = 0;
let x2_origem = x2;
s = 1;
let s_origem = s;
w1 = 0.2;
w2 = 0.4;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
while (loop) {
// linha 2 (body)
x1 = 2;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 3 (body)
x1 = 2;
x2 = 5;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 4 (body)
x1 = 3;
x2 = 0;
s = 1;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 5 (body)
x1 = 1;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 6 (body)
x1 = 1;
x2 = 0;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
// linha 7 (body)
x1 = 0;
x2 = 5;
s = 0;
w1 = nw1;
w2 = nw2;
d = ((x1 * w1) + (x2 * w2) + bias);
if (d >= 0) {
a = 1;
} else {
a = -1;
}
if (a === 1) {
p = 1;
} else {
p = 0;
}
e = s - p;
vetor[cont] = e;
cont++;
d1 = ta * x1 * e;
d2 = ta * x2 * e;
nw1 = w1 + d1;
nw2 = w2 + d2;
if (cont >= 500) {
for (let i = 0; i < 499; i++) {
if (vetor[i] === 0) {
padrao++;
} else {
padrao = 0;
}
if (padrao > 15) {
loop = false;
}
}
document.write('Bias: ', bias + '<br/>');
document.write('Taxa de aprendizado: ', ta + '<br/>');
document.write('X1: ' + x1_origem + '<br/>');
document.write('X2: ' + x2_origem + '<br/>');
document.write('S: ' + s_origem + '<br/>');
document.write('W1 encontrado: ' + w1.toFixed(2) + '<br/>');
document.write('W2 encontrado: ' + w2.toFixed(2));
}
}
}
Saída
Bias: -1 Taxa de aprendizado: 0.01 X1: 2 X2: 0 S: 1 W1 encontrado: 0.50 W2 encontrado: 0.05
Caso queiram executar o código acima (Javascript) em html, basta deixar sua tag body conforme abaixo. Lembrem-se: a function neuronio() deve estar dentro de uma tag script, que por sua vez deve estar dentro de head
<body onload="neuronio()">
Este é um tema bastante utilizado em trabalhos acadêmicos para as áreas de tecnologia em que envolvem programação. Espero que tenha contribuído de alguma forma para o parendizado de alguém. Acredito que a partir deste exemplo, possam implementar tal neurônio com facilidade em outros tipos de problemas.
Custos com hospedagem, SSL e registro de domínio
Se o artigo ajudou de alguma forma e gostaria de contribuir com o projeto Fedablio, faça uma doação de qualquer valor.
Chave PIX: 21d97524-aa38-4438-b857-062a61e28327