UNIVERSIDADE FEDERAL DE UBERLNDIA

Faculdade de Engenharia Eltrica

INTELIGNCIA ARTIFICIAL
Prof. Keiji Yamanaka

Software em C# para treinamento de neurnios via regra

de Hebbs

PMELLA BERNARDES 11021EEL038

Uberlndia
2014

1. Resumo
Neste trabalho ser desenvolvida uma interface grfica na
linguagem de programao C#, utilizando o software Visual Basic
C#. Nesta interface contm as 16 tabelas verdades de duas
entradas, com suas respectivas sadas, a ideia aplicar a regra de
Hebbs uma rede neural artificial, de tal forma a treinar o sistema
para que ele consiga obter a sada correta.

Palavras-chave: C#, regra de Hebbs, RNA, tabela verdade, redes neurais artificiais

Abstract
In this work, will be developed a graphical interface in the C # programming
language using Visual Basic C # software. This interface contains 16 two-input truth
tables, with their respective outputs, the idea is to apply the rule of Hebbs an artificial
neural network, in such a way to train the system so that he can get the correct output.

Keywords: C#, Rule of Hebbs, ANN, artificial neural networks, truth tables

Contedo
1.

Resumo...................................................................................................... 2

2.

Introduo.................................................................................................. 4

3.

Desenvolvimento......................................................................................... 5

4.

Concluso................................................................................................... 7

5.

Referncias Bibliogrficas...........................................................................8

6.

Apndice A (Cdigo fonte do programa).......................................................9

2. Introduo

A regra de aprendizado de Hebb prope que o peso de uma

conexo sinptica deve ser ajustado se houver sincronismo entre os
nveis de atividade das entradas e sadas [Hebb, 1949]. De acordo
com Hebbs, a efetividade de uma sinapse aumenta devido ao
repetitiva de um neurnio. A figura abaixo ilustra de forma sucinta
essa relao.

Figura 1 Regra de Hebb

Declarao de hebb: Quando um axnio de uma clula A est

prximo o suficiente de excitar a clula e repetidamente ou
persistentemente participa da ativao desta, um processo de
crescimento ou mudana metablica ocorre em uma ou ambas as
clulas, de tal forma que a eficincia de A em ativar B aumentada.
A regra proposta por Hebb um treinamento no
supervisionado, no qual o conjunto de treinamento consiste em um
vetor de entrada. O algoritmo de treinamento modifica os pesos da
rede para produzir um vetor de sada consistente com a entrada.
Deste modo pde-se obter o seguinte algoritmo de treinamento:

Passo 0: Inicializar todos os pesos: wi = 0 (i = 1, ..., n);

Passo 1: Para cada par de vetor de treinamento (s) e alvo (t):
a) Atribuir o vetor de treinamento s unidades de entrada:
xi = si ( i = 1,..., n);
b) Atribuir o alvo unidade de sada: y = t;

c) Ajustar os pesos: wi (novo) = wi (velho) + xi y (i = 1,..., n);

Ajustar o bias: b(novo) = b(velho) + y;

Figura 2 Fluxograma referente a regra de Hebbs

3. Desenvolvimento
Para o desenvolvimento deste projeto foi necessrio uma breve
reviso acerca do software para desenvolvimento de interfaces
grficas da Microsoft Visual Basic C#. Assim, os clculos para
treinamento de Hebbs foi feito programando cada boto, label e
caixa de texto.
Primeiramente foi criada uma combobox contendo todas as 16
tabelas verdades para duas variveis de entrada, na qual o usurio
deve selecionar a lgica de seu interesse de acordo com a figura 1.
Esta combobox foi programada de tal forma a conter um banco de
dados internamente na linha de cdigo, definindo os valores para
cada label.

Figura 3 Combobox para a escolha da tabela verdade.

Aps este passo o programa j calcula automaticamente os
valores dos pesos e ento o aluno pode clicar no boto Treinar o
qual ir trinar a rede de neurnios atravs da regra de hebbs e obter
os pesos finais. A lgica em linhas de cdigo utilizada para o
treinamento dos neurnios pode ser visualizada na Tabela 1 abaixo.
Como se pode perceber as variveis foram inicializadas com valores
nulos e pode ser implementada a lgica para treinamento. O evento
Convert.ToInt16 possui a funo de converter o texto da textbox para
inteiro e assim ser efetuado o clculo.
Depois de o sistema ser treinado bastou ento realizar um teste
inserindo o valor do limiar e das entradas X1 e X2 para que uma
determinada sada fosse obtida. Se o valor da sada obtida for igual
ao da sada disposta na tabela verdade, ento o treinamento
funcionou. A figura 2 abaixo mostra a interface pronta para ser
utilizada.

Figura 4 Interface da Regra de Hebbs finalizada

Pode-se dizer que a etapa mais complicada no desenvolvimento deste
trabalho foi a elaborao da interface grfica e programao de cada um de
seus elementos, visto que h muito tempo o aluno no trabalhava com tal
software. A ideia ainda implementar este trabalho de tal forma a desenvolver a
funcionalidade de interpretao geomtrica do problema, alm de outras opes
de treinamento de redes neurais e incluso de rudos na sada.

4. Concluso
A partir do desenvolvimento deste trabalho foi mais perceptvel para o
estudante as iteraes promovidas pelos pesos afim de treinar a rede neural
com a sada j conhecida para encontrar esta mesma sada com a menor taxa
de erros possvel. Como no foram adicionados rudos na sada no possvel
perceber o tratamento da regra de Hebbs para esse tipo de anomalia, porm
esta funcionalidade ainda ser implementada.

5. Referncias Bibliogrficas
[1] http://www.lncc.br/~labinfo/tutorialRN/frm1_introducao.htm.
Acedido dia 06/05/2014.
[2]
http://www2.ica.ele.puc-rio.br/Downloads/30/ICA-Aula-2bPerceptron.pdf
[3]
ftp://ftp.dca.fee.unicamp.br/pub/docs/vonzuben/ia353_03/topico5
_03.pdf
[4]
http://pt.slideshare.net/jkbrandao/redes-neurais-artificiaisregras-de-aprendizado
[5]
http://www.decom.ufop.br/imobilis/wpcontent/uploads/2012/06/02_Treinamento-e-Aprendizado-emRNAs.pdf

6. Apndice A (Cdigo fonte do programa)

using
using
using
using
using
using
using
using

System;
System.Collections.Generic;
System.ComponentModel;
System.Data;
System.Drawing;
System.Linq;
System.Text;
System.Windows.Forms;

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Saida_escolha_SelectedIndexChanged(object sender, EventArgs e)
{
if (Saida_escolha.SelectedIndex == 0)
{
Y1.Text = "-1";
Y2.Text = "-1"; //Sada 0
Y3.Text = "-1";
Y4.Text = "-1";
}
else if (Saida_escolha.SelectedIndex == 1)
{
Y1.Text = "-1";
Y2.Text = "-1";
Y3.Text = "-1";// Sada 1
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex == 2)
{
Y1.Text = "-1";
Y2.Text = "-1";
Y3.Text = " 1";//Sada 2
Y4.Text = "-1";
}
else if (Saida_escolha.SelectedIndex == 3)
{
Y1.Text = "-1";
Y2.Text = "-1";
Y3.Text = " 1";// Sada 3
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex == 4)
{
Y1.Text = "-1";
Y2.Text = " 1";// 4
Y3.Text = "-1";
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex == 5)
{
Y1.Text = "-1";
Y2.Text = " 1";
Y3.Text = "-1"; //5
Y4.Text = " 1";
}

else if (Saida_escolha.SelectedIndex
{
Y1.Text = "-1";
Y2.Text = " 1"; //6
Y3.Text = " 1";
Y4.Text = "-1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = "-1";
Y2.Text = " 1";
Y3.Text = " 1"; // 7
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = "-1"; //8
Y3.Text = "-1";
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = "-1"; // 9
Y3.Text = "-1";
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = "-1"; //10
Y3.Text = " 1";
Y4.Text = "-1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = "-1";
Y3.Text = " 1";//11
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = " 1";//12
Y3.Text = "-1";
Y4.Text = "-1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = " 1";
Y3.Text = "-1";//13
Y4.Text = " 1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";
Y2.Text = " 1";//14
Y3.Text = " 1";
Y4.Text = "-1";
}
else if (Saida_escolha.SelectedIndex
{
Y1.Text = " 1";

== 6)

== 7)

== 8)

== 9)

== 10)

== 11)

== 12)

== 13)

== 14)

== 15)

Y2.Text = " 1";

Y3.Text = " 1";//15
Y4.Text = " 1";
}
}
private void Calc_par_Click(object sender, EventArgs e)
{
int dw11, dw12, dw13, dw14, X1, X2, X3, X4, Y11, Y12, Y13, Y14;
try
{
// CLCULO dw1
X1 = Convert.ToInt16(X11.Text);
Y11 = Convert.ToInt16(Y1.Text);
dw11 = X1 * Y11;
w11.Text = dw11.ToString();
// CLCULO dw2
X2 = Convert.ToInt16(X12.Text);
Y12 = Convert.ToInt16(Y2.Text);
dw12 = X2 * Y12;
w12.Text = dw12.ToString();
// CLCULO dw3
X3 = Convert.ToInt16(X13.Text);
Y13 = Convert.ToInt16(Y3.Text);
dw13 = X3 * Y13;
w13.Text = dw13.ToString();
// CLCULO dw4
X4 = Convert.ToInt16(X14.Text);
Y14 = Convert.ToInt16(Y4.Text);
dw14 = X4 * Y14;
w14.Text = dw14.ToString();
int dw21, dw22, dw23, dw24, x1, x2, x3, x4;
//CLCULO dw21
x1 = Convert.ToInt16(X21.Text);
Y11 = Convert.ToInt16(Y1.Text);
dw21 = x1 * Y11;
w21.Text = dw21.ToString();
//CLCULO dw22
x2 = Convert.ToInt16(X22.Text);
Y12 = Convert.ToInt16(Y2.Text);
dw22 = x2 * Y12;
w22.Text = dw22.ToString();
//CLCULO dw23
x3 = Convert.ToInt16(X23.Text);
Y13 = Convert.ToInt16(Y3.Text);
dw23 = x3 * Y13;
w23.Text = dw23.ToString();
//CLCULO dw24
x4 = Convert.ToInt16(X24.Text);
Y14 = Convert.ToInt16(Y4.Text);
dw24 = x4 * Y14;
w24.Text = dw24.ToString();
// Valor do Deltab
b1.Text = Y1.Text;
b2.Text = Y2.Text;
b3.Text = Y3.Text;

b4.Text = Y4.Text;
}
catch
{
MessageBox.Show("Escolha uma sada.");
}

}
private void Treino_Click(object sender, EventArgs e)
{
int W1 = 0, W2 = 0, B = 0, a, bi, c, d;
try
{
//Treinamento w1
a = W1 + Convert.ToInt16(w11.Text);
bi = a + Convert.ToInt16(w12.Text);
c = bi + Convert.ToInt16(w13.Text);
d = c + Convert.ToInt16(w14.Text);
w1.Text = Convert.ToString(d);
//Treinamento w2
a = W2 + Convert.ToInt16(w21.Text);
bi = a + Convert.ToInt16(w22.Text);
c = bi + Convert.ToInt16(w23.Text);
d = c + Convert.ToInt16(w24.Text);
w2.Text = Convert.ToString(d);
//Treinamento b
a = B + Convert.ToInt16(b1.Text);
bi = a + Convert.ToInt16(b2.Text);
c = bi + Convert.ToInt16(b3.Text);
d = c + Convert.ToInt16(b4.Text);
b.Text = Convert.ToString(d);
}
catch
{
MessageBox.Show("Calcule primeiro os parmetros!");
}
}
private void teta_KeyPress(object sender, KeyPressEventArgs e)
{
char ch = e.KeyChar;
if (!Char.IsDigit(ch) && ch != 8 && ch == 45)
{
e.Handled = true;
}
}
private void Testar_Click(object sender, EventArgs e)
{
// mensagem para o usuario no deixar o campo Limiar em branco
string texto = teta.Text;
string texto1 = X1.Text;
string texto2 = X2.Text;
if (teta.Text != "" || X1.Text != "" || X2.Text != "")
{
}
else
{
MessageBox.Show(" Insira os valores \n de X1, X2 e Limiar");
}

//Teste do neurnio
int nw1, nw2, b1, xis1, xis2, net, tets;
nw1 = Convert.ToInt16(w1.Text);
nw2 = Convert.ToInt16(w2.Text);
b1 = Convert.ToInt16(b.Text);
xis1 = Convert.ToInt16(X1.Text);
xis2 = Convert.ToInt16(X2.Text);
tets = Convert.ToInt16(teta.Text);
net = nw1 * xis1 + nw2 * xis2 + b1;
if (net >= tets)
{
Y.Text = "1";
}
else
{
Y.Text = "-1";
}

}
private void button1_Click(object sender, EventArgs e)
{
w1.Clear();
w2.Clear();
w11.Clear();
w12.Clear();
w13.Clear();
w14.Clear();
w21.Clear();
w22.Clear();
w23.Clear();
w24.Clear();
b.Clear();
b1.Clear();
b2.Clear();
b3.Clear();
b4.Clear();
Y1.Clear();
Y2.Clear();
Y3.Clear();
Y4.Clear();
teta.Clear();
X1.Clear();
X2.Clear();
Y.Clear();
}
}