INSTITUTO FEDERAL DE MINAS GERAIS CAMPUS BAMBUMANUTENO AUTOMOTIVA

TALIS MAJELA
FHELIPE DE MOURA
MICHEL LEANDRO
JEAN D'ORNELLAS

PROJETO AVALIATIVO
MANUTENO NA INDUSTRIA AUTOMOTIVA

BAMBU

MG
2014

NOVEMBRO DE

RESUMO
Este trabalho apresenta as necessidades atuais para garantir qualidade e alta produtividade de bens
e servios ,associadas ao valor crescente do capital intelectual e ao volume de informao existente e
dispersas nas organizaes,exigem prticas cada vez mais eficazes,especialmente na rea de
manuteno industrial. O modelo proposto para o desenvolvimento concebido atravs de um grafo
conceitual. Com base na analise dos mecanismos de falhas, e caracterizado por um modelo hbrido
de representao do conhecimento, combinando tcnicas de inferencias de raciocinio baseado em
regras(RBR) de raciocinio baseado em casos (RBC). Adicionalmente as apresentaes dos pontos
principais de cada etapa de desenvolvimento, o artigo aborda como conhecimento heuristico, utilizado
na analise causal de sistemas fisico industriais, pode ser compartilhado no ambiente de manufatura e
estabelece uma aproximao para o uso de sistema como ferramenta para ambos os
setores,educacional e industrial.

Palavras chave: diagnostico de falhas, manutenao industrial e automotiva, raciocinio, sistemas

especialista.

ABSTRACT

This paper presents the current needs to ensure high productivity and quality of goods and services
associated with the increasing value of intellectual capital and the volume of existing, dispersed
information in organizations require increasingly effective practices, especially in the area of industrial
maintenance. The proposed model for the development is made with a conceptual graph. Based on
the analysis of failure mechanisms, and is characterized by a hybrid model of knowledge
representation, combining techniques inferences from rules-based reasoning (RBR) of case-based
reasoning (CBR). Besides the presentations of each major stage of development points, the article
discusses how heuristic knowledge used in the causal analysis of industrial physical systems, can be
shared in a manufacturing environment and establishes an approach for using the system as a tool for
both sectors , educational and industrial.

Keywords: fault diagnosis, industrial and automotive maintenance, reasoning, expert systems.

SUMRIO
1)Introduo
2) SISTEMAS BASEADOS EM CONHECIMENTO
2.1) Manuteno Industrial
2.2) Aquisio do Conhecimento
2.3) Representao do Conhecimento
2.3.1) Mtodos de Inferncia
2.3.2) Tcnicas de Representao para o Tratamento de
Incerteza
2.4) Implementao e Validao do Conhecimento
3) CONCLUSO
4) AGRADECIMENTOS

1. INTRODUO
Est relacionada ao modo como as empresas gerenciam e criam novos
conhecimentos, disseminando os atravs da
organizao e incorporando
os rapidamente em novas tecnologias e produtos (Nonaka, In: Starkey,
1997).
Deste modo, empresas tambm competem pelo conhecimento superior
sobre seus processos e no apenas pela
criatividade no desenvolvimento de seus produtos, de forma que estes
so considerados manifestaes concretas do conhecimento e o quanto
valem depende em grande parte, se no inteiramente, do valor do saber que
incorporam (LeonardBarton, 1998).
Quando uma empresa valoriza o conhecimento como um ativo
corporativo, compreendendo a importncia da
necessidade de sua gesto, ela gera retornos crescentes e propicia a
busca por uma vantagem empresarial sustentvel.
A competitividade exigida pela economia globalizada estimula a inovao
contnua e valoriza o profissional com conhecimento terico e prtico altamente
especializado. A nica fonte garantida de vantagem competitiva duradoura
Ao contrrio dos ativos materiais, que diminuem medida que so
usados, os ativos do conhecimento aumentam com
o uso: idias geram novas idias [...] (Davenporte Prusak, 1998).

2. SISTEMAS BASEADOS EM CONHECIMENTO

Gonzalez e Dankel (1993, p. 21) definem um sistema baseado em conhecimento
(SBC) como quele que utiliza o
conhecimento sobre um determinado domnio para chegar a uma soluo de um
problema daquele domnio. Esta
soluo essencialmente a mesma que aquela obtida por uma pessoa com
conhecimento a respeito do mesmo domnio
do problema, quando confrontado com o mesmo problema.
De todos os sistemas baseados em conhecimento, o que possui maior aplicabilidade
em setores comerciais e
industriais so os sistemas especialistas (SE), cujo objetivo transferir a experincia
de um perito e de fontes
documentadas para um computador e, posteriormente, para o usurio. Observa-se
que os termos SBC e SE podem ser
intercambiveis, mas de forma unvoca, pois, um SE considerado um caso
particular de um SBC e no o contrrio
(Turban et al, 2003).
Silva (1998) ressalta que sistemas especialistas se constituem em um dos principais
tpicos da rea de inteligncia
artificial (IA), na medida em que ela estuda o desenvolvimento de modelos formais
para a inteligncia humana, com a
explorao de tcnicas computacionais para a simulao do comportamento
inteligente.
Das categorias genricas propostas por Waterman (1986), a categoria de SE
aplicada ao diagnstico a que
determina em situaes complexas, como na rea de manuteno, a causa do mau
funcionamento de um item com base
nos efeitos (sintomas) observveis em seus processos de fabricao. Em geral,
representa sistemas que possuem uma
ampla gama de variveis e que podem assumir diversos valores, tornando mais
rpida a soluo de problemas desta
natureza, alm de melhorarem a qualidade de suas decises (Abel, 1998).

2.1.MANUTENO INDUSTRIAL
Ainda que mquinas sejam projetadas para trabalhar com zero defeito, na prtica, o
que ocorre que se um item
no tiver falhado dentro de um determinado perodo de tempo, ir falhar em um
instante futuro. Tal fato refora para a
manuteno sua vocao estratgica, sendo fundamental para a competitividade
industrial (Dias, 1996).
Ento, alinhada gesto da manufatura, a rea de manuteno pode adquirir uma
abordagem estratgica quando,
alm de manter itens disponveis por um longo perodo de tempo, reduzindo ao
mximo sua probabilidade de falha,
conseguir incorporar as suas atividades e aos seus processos, conhecimentos
articulveis, patenteveis e no disponveis
em fontes pblicas, transformando-se em conhecimentos superiores aos dos seus
concorrentes.
Exatamente durante o processo de desenvolvimento do SE para o diagnstico de
falha, que idias, informaes e
conceitos devem ser revistos e produzidos, transformando-se em bens cognitivos,
de tal forma que SE possam propiciar
um conhecimento superior sobre seus processos e se constituir em um meio
altamente eficaz para a criao de novos
conhecimentos. Isto ocorre pela captura das intuies, recomendaes ou insights
dos especialistas e colaboradores em
manuteno, tornando os bens cognitivos disponveis dinamicamente para serem
comunicados e compartilhados por toda a organizao.
Bens cognitivos podem ser vistos como o conhecimento explcito, formal,
sistemtico, de fcil codificao,
representado e obtido atravs de treinamento em manuais, livros e conferncias.
Mas, tambm podem ser vistos como

conhecimento implcito, altamente pessoal e subjetivo e, nesse caso, difcil de ser

formalizado e sistematizado. Este tipo
de conhecimento est enraizado na ao e no comprometimento.
2.2.Aquisio do Conhecimento.

3. REDES NEURAIS ARTIFICIAIS RNA

O estudo das RNA advm dum conceito de importncia na computao, responsvel
pela soluo de muitos problemas complexos.
Redes neurais artificiais vm de um conceito da computao que visa
trabalhar no processamento de dados de maneira semelhante ao crebro humano e
segundo ALECRIM, (2004):
O crebro tido como um processador altamente complexo e que
realiza processamentos de maneira paralela. Para isso, ele organiza
sua estrutura, ou seja, os neurnios, de forma que eles realizem o
processamento necessrio. Isso feito numa velocidade extremamente
alta e no existe qualquer computador no mundo capaz de realizar o
que o crebro humano faz.

A Figura 19 mostra a representao da estrutura de um neurnio humano,

mostrando suas principais estruturas.

Fig. 1: Representao de um neurnio humano

A idia da RNA realizar o processamento de informaes tendo como

princpio a organizao de neurnios do crebro humano e fazer, atravs de clculos
matemticos, com que uma determinada aplicao seja capaz de aprender e tomar
decises baseadas na aprendizagem [2]. Desse modo as RNA podem ser ditas
como um esquema de processamento capaz de armazenar conhecimento baseado
em aprendizagem (experincia) e disponibilizar este conhecimento para a aplicao
em questo.
O aprendizado das RNA criado a partir de algoritmos projetados para
uma determinada finalidade [4]. Para este estudo de caso, a finalidade o
reconhecimento de cores, sendo que uma RNA assemelha-se ao crebro por obter

conhecimento atravs de etapas de aprendizagem e pesos sinpticos 1 que so

usados para armazenar o conhecimento.
Existem vrias formas de se desenvolver uma rede neural. Ela deve ser
montada de acordo com o problema a ser solucionado sendo que na sua arquitetura
so determinados o nmero de camadas usadas, a quantidade de neurnios em
cada camada, o tipo de sinapse a ser utilizada, por exemplo.
Na Figura 20 tem-se um exemplo, mais simplrio, de uma Rede Neural
Artificial de 2 camadas com 4 entradas e 2 sadas.

Fig. 2: Exemplo de uma Rede Neural Artificial de 2 camadas com 4 entradas e 2 sadas

Segundo ALECRIM, (2004):

O processo de aprendizagem das redes neurais realizado quando
ocorrem vrias modificaes significantes nas sinapses dos neurnios.
Essas mudanas ocorrem de acordo com a ativao dos neurnios. Se
determinadas conexes so mais usadas, estas so reforadas
enquanto que as demais so enfraquecidas. por isso que quando uma
rede neural artificial implantada para uma determinada aplicao,
necessrio um tempo para que esta seja treinada.

Existem, basicamente, 3 tipos de aprendizado nas redes neurais

artificiais:
1. Supervisionado;
2. No-supervisionado;
3. Hbrido (misto dos tipos supracitados).

sinapse o nome dado conexo existente entre neurnios.

A princpio pensou-se em trabalhar com a RNA supervisionada Multy

Layer Perceptron (MLP) por ser uma das mais conhecidas e por resolver uma
grande quantidade de aplicaes do mundo real. Ao implement-la passou-se a
observar que na fase de aprendizado o erro obtido em cada poca crescia no
caracterizando a convergncia da rede. Por questes de prazo, optou-se por
substituir o MLP pela rede Adaline que apesar de ser de camada simples (resolve
apenas problemas linearmente separveis problemas em que apenas usando
retas consegue-se separar os padres que se diferem) possui aprendizado baseado
na regra Delta e mais simples de implementar que o MLP. Para comparar com a
rede Adaline usou-se a rede Kohonen que no-supervisionada e competitiva
baseada em cluster.
Escolheu-se como padro para reconhecimento as cores preto, vermelha,
azul, amarela e branca, sendo que na Figura 19 mostra os blocos coloridos do
LEGO que foram expostos para o reconhecimento de padro do RSC.

Fig. 3: Blocos LEGO coloridos que foram expostos para o reconhecimento de padro

3.1. REDES NEURAIS ARTIFICIAIS SUPERVISIONADAS

A RNA supervisionada uma rede neural que recebe um conjunto de entradas
padronizado e define-se os seus correspondentes padres de sada (sadas
desejadas ou alvos). A idia apresentar as entradas, gerar as respectivas sadas e
compar-las com os alvos. Se forem diferentes, calcula-se os erros de cada
neurnio e ajusta-se os seus pesos sinpticos de acordo com os erros calculados
com o intuito de que a cada poca gerada, ao apresentar todos os padres de

entrada de novo, esse erro tenda a zero. H alguns tipos de RNA supervisionadas
como Perceptron, MLP, Adaline, Madaline, e outras...

3.1.1. ADALINE
Adaptive Linear Neuron (Adaline) uma rede de camada simples (possui somente
camada de entrada de dados e camada de sada) que utiliza a regra Delta para
realizar seu aprendizado, ou seja, considera o aparecimento de um erro que
influenciar na correo dos pesos.
A arquitetura da rede Adaline usada no estudo de caso deste trabalho
mostrada na Figura 22.

Fig. 4: Arquitetura da RNA Supervisionada Adaline para o estudo de caso

Observe que cada unidade de entrada conecta-se com cada neurnio na

camada de sada de acordo com um determinado peso de conexo. Alm disso,
considera-se uma unidade com valor fixo e unitrio que serve para dar maior
estabilidade aos neurnios quando estes responderem s entradas apresentadas.
Sempre que for apresentado um novo padro rede, cada unidade de
entrada multiplicada com seu respectivo peso e isso dar um valor parcial do sinal
de entrada que chegar num neurnio.
Como cada neurnio na camada de sada recebe todos os sinais que vem
da camada de entrada ento faz-se um somatrio destes para gerar a entrada total
em cada neurnio. Pela regra Delta, se a entrada de um neurnio for diferente do
seu alvo, ento, atualizam-se suas conexes de acordo com esse erro observado.

Aps o treinamento da rede, ou seja, aps observar-se que o erro gerado

em cada neurnio tal que a divergncia entre a entrada e o alvo para cada padro
de entrada pequena (aceitvel dentro de uma tolerncia permitida e definida
inicialmente) inicia-se a fase de simulao que apresentar cada padro de entrada
rede e verificar se ela realmente gera sadas satisfatrias.
Para gerar as sadas calculadas em cada neurnio usa-se uma funo de
ativao que no caso do Adaline ser +1 se a entrada for positiva e -1 se a entrada
for negativa.
A seguir so mostradas as etapas realizadas para o estudo de caso
usando o Adaline.
3.1.1.1. Aquisio das Entradas
apresentar 5 cores diferentes ao RSC;
obter 5 cdigos de cores no formato inteiro atravs do RSC;

gerar uma matriz de cdigos (binrios ou bipolares) que ser a entrada da rede Adaline
conforme Quadro 1.
ENTRADA DA REDE ADALINE
CORES 1
X1
X2
X3
X4
X5
X6
X7
Cor 1
1
0
0
0
0
0
0
0
Cor 2
1
0
0
1
1
1
1
1
Cor 3
1
1
0
1
0
0
1
1
Cor 4
1
0
1
0
1
0
0
0
Cor 5
1
1
0
1
1
1
0
0
Quadro 1: Matriz de cdigos binrios representando a entrada da rede Adaline

3.1.1.2. PARMETROS INICIAIS DO TREINAMENTO

= Taxa de Aprendizado (-1 1 ) ou (-0.5 0.5);

Tolerncia = tolerncia mxima de erro permitido;

Max_epoc = nmero mximo de pocas;

t = sada desejada ou alvo (target).

O t uma matriz 5x3 do tipo bipolar conforme Quadro 2.

Alvo 1
1
1
1
Alvo 2
1
1
-1
Alvo 3
1
-1
1
Alvo 4
1
-1
-1
Alvo 5
-1
1
1
Quadro 2: Matriz 5x3 do tipo bipolar para representao do Alvo

O alvo 1 representa a sada desejada na rede quando a cor apresentada for a

cor 1;

A codificao da matriz t feita de forma aleatria e uma vez criada, no ser

alterada.

3.1.1.3. INICIALIZAO DOS PESOS

A matriz dos pesos W iniciada com valores aleatrios entre -1 e 1 ou entre

-0.5 e 0.5, veja o exemplo mostrado no Quadro 3.
Representao da matriz dos pesos (W) do Adalune
-0.30
0.02
0.90
0.14
-0.01
-0.83
Quadro 3: Representao da matriz dos pesos (W) do Adaline

3.1.1.4. TREINAMENTO DO ADALINE

1. Inicialize os pesos (wi,j) aleatoriamente;
2. Setar a taxa de aprendizado () e o erro mximo permitido;
3. Setar o alvo (t k,j) e o nmero mximo de pocas.
4. Enquanto no atingir o critrio de parada, faa:
Para cada padro de entrada e o alvo, faa:
Calcular a entrada total de cada neurnio:
7

Yent J = X ki . Wij
i=0

Atualizar os pesos:
Wi,J = Wij + . (tj,k - Yent J) . x k,i
Verificar critrio de parada.
5. Fim.
3.1.1.5. CRITRIO DE PARADA

1. Pode-se usar o erro quadrtico mdio (rms) da rede, que para o estudo de caso
definido por:
2

rms = (tj,k - Yent J)2

j=0

2. Pode-se usar o nmero mximo de pocas, lembrando que uma poca equivale
a apresentar todos os padres de entrada rede.
3. Pode-se usar os critrio 1 e 2 juntos.

3.1.1.6. SIMULAO DO ADALINE

1.

Uma vez que se fez o aprendizado da rede, os pesos so fixados;

2.

Espera-se que ao apresentar um padro de entrada (uma cor entre as 5

treinadas) a sada obtida no Adaline seja igual sada desejada (alvo).
Para cada padro de entrada apresentado, faa:
7

Yent J = X ki . Wij
i=0

1.1 Aplicar a funo de ativao:

Y=

1, se Yent J 0
-1 se Yent J < 0

3.1.1.7. RESPOSTA AO RSC

A sada obtida no Adaline identificada e enviada ao RSC que saber qual
cor a rede detectou;
Ao saber qual cor foi detectada, o RSC ir colocar a pea com a referida cor
na devida opo.
3.1.1.8. OBSERVAO
Na fase de simulao, cada padro de entrada no Adaline uma cor lida pelo RSC.
Se o RSC ler duas peas azuis pode acontecer, devido ao sensor de luz, de ambas
possuir cdigos prximos ou no. Isso uma limitao de hardware e faz com que a

rede gere sadas duvidosas. Por isso a tolerncia deve ser definida de forma a fazer
com que a rede gere sadas satisfatrias.
3.1.2. MULTY LAYER PERCEPTRON - MLP
O Perceptron Multi-Camadas (MLP) uma extenso do Perceptron de camada
nica ou simples. Esta arquitetura apresenta uma camada com unidades de entrada,
conectada a uma ou mais camadas com unidades intermedirias, chamadas
camadas ocultas, e uma camada de unidades de sada.
O MLP utiliza-se de um processo de aprendizado supervisionado, assim
como o Adaline, sendo mais comum para seu aprendizado a utilizao do algoritmo
"Backpropagation2".
A Figura 23 mostra uma arquitetura de um MLP.

Fig. 5: Arquitetura de um MLP

Depois que a rede estiver treinada e o erro estiver em um nvel

satisfatrio (dentro de uma tolerncia pr-definida), ela poder ser utilizada como
uma ferramenta para classificao de novos dados. Para isto, a rede dever ser
utilizada na fase de simulao apenas no modo progressivo (feed-forward).
As redes neurais que utilizam o backpropagation como algoritmo de
aprendizado, podem ser vistas como "caixas pretas", na qual quase no se sabe
Durante o treinamento com o algoritmo backpropagation, a rede opera em uma
sequncia de dois passos. Primeiro, um padro apresentado camada de entrada da
rede. A atividade resultante flui atravs da rede, camada por camada, at que a resposta
seja produzida pela camada de sada. No segundo passo, a sada obtida comparada
sada desejada para esse padro particular. Se esta no estiver correta, o erro
calculado. O erro propagado a partir da camada de sada at a camada de entrada, e os
pesos das conexes das unidades das camadas internas vo sendo modificados conforme
o erro retropropagado.
2

porque a rede chega a um determinado resultado, uma vez que os modelos no

apresentam justificativas para suas respostas.
Como, para o estudo do RSC, no foram obtidos resultados satisfatrios
este tipo de rede no fora utilizada, mas seu cdigo para o RSC encontra-se no
Apndice 3.

3.2. REDES NEURAIS ARTIFICIAIS NO-SUPERVISIONADAS

As RNA do tipo no-supervisionadas um tipo de rede neural que trabalha com os
dados de forma a determinar algumas propriedades dos conjuntos de dados. A partir
destas propriedades que o aprendizado constitudo. Nestes casos no h alvos a
serem comparados com as entradas dos neurnios, ou seja, no se conhecem quais
classes de padres sero apresentadas rede.
Para o projeto do RSC fora escolhida a Rede Kohonen para verificao
de padres de cores por se tratar de uma rede com aprendizado fcil de
implementar se comparado a outras da mesma categoria.
3.2.1. KOHONEN
Esta rede apresenta uma camada de entrada e uma camada de sada que
comumente chamada de camada de cluster. Essa camada de cluster pode
apresentar topologias diferentes sendo as mais comuns as topologias lineares
representadas por vetores e as topologias em grades representadas por matrizes
bidimensionais.
A proposta do aprendizado que os neurnios faam uma competio
entre si a cada padro de entrada apresentado sendo que apenas um deles ser o
vencedor. Dizer que o neurnio o vencedor para um certo padro de entrada
dizer que ele ser o que melhor responder na sada toda vez que esse padro for
apresentado rede.
Como critrio de competio calcula-se a distncia Euclidiana de cada
neurnio sendo que aquele que apresentar menor distncia Euclidiana para aquele
padro de entrada ser o vencedor. Quando se define o neurnio vencedor
atualizam-se os pesos relacionados a ele e tambm aos seus vizinhos. O raio de
vizinhana um parmetro a ser definido no inicio do treinamento e pode diminuir

durante o mesmo. Outro parmetro que pode diminuir durante o treinamento a

taxa de aprendizado que normalmente inicia-se prxima de 1.
O treinamento possui duas fases que so: fase de organizao dos
clusters e fase de refinamento dos clusters.
A arquitetura utilizada no estudo de caso considerando topologia linear de
clusters mostrada na Figura 24.

Fig. 6: Esquema explicativo do funcionamento da RNA No-supervisionada Kohonen

3.2.1.1. CONSIDERAES
A idia que aps o treinamento da rede, cada cluster responda melhor a
uma determinada cor.
Cada cdigo de cor convertido em binrio (7 bits) considerando que o maior
cdigo possvel de cor seria 100 (normalizao).
Se duas cores possurem cdigos binrios parecidos, pode acontecer da rede
classific-las como pertencente ao mesmo cluster (mesma classe).
Ex.: Suponha que:
Cor
Azul
Amarelo

Cdigo Decimal
30
94

Cdigo Binrio
0011110
1011110

Os cdigos inteiros dessas cores so distintos na faixa de 0 a 100, mas o cdigo

binrio delas semelhante, considerando-se 7 bits.
Falar que um cluster responde melhor a uma cor dizer que este neurnio foi
o vencedor para a cor.
Neurnio vencedor aquele que possui a menor distncia Euclidiana para
essa cor;
A distncia Euclidiana obtida fazendo-se a diferena entre os pesos e as
entradas para um certo cluster.

3.2.1.2. ALGORITMO
1. Inicializar os pesos (wi,j) entre -0.5 e 0.5 ou -1 e 1;
2. Inicializar a taxa de aprendizado, prxima de 1 (= 0.9, por exemplo);
3. Inicializar o raio de vizinhana r (r = nCluster 1, por exemplo);
4. Usar topologia linear para a camada de cluster;
5. Fazer a fase de organizao dos neurnios (clusters);
6. Fazer a fase de refinamento dos neurnios (clusters).
3.2.1.3. FASE DE ORGANIZAO

Indica-se, de pocas em pocas, decrementar o raio de vizinhana at 2.

Indica-se reduzir linearmente o at 0.1 a cada poca.

Realiza-se uma mdia de 1000 pocas nesta fase.

Por exemplo: = * 0.9

5.1.

Para cada padro de entrada Wk,i, faa:

5.1.1. Para cada cluster yj, faa:

5.1.1.1.

Calcular as distncias Euclidianas:

6

D(J) = (Wij - X ki)2

i=0

5.1.2. Encontrar o cluster vencedor (Menor D(J) )

5.2.

Para todos os J-simos clusters vizinhos do cluster vencedor e o prprio,

atualize os pesos:
Wij = Wij + .(Wij - X ki)

5.3.

Reduzir

5.4.

Reduzir r

3.2.1.4. FASE DE REFINAMENTO

O raio de vizinhana fixo: r = 0 ou r = 1;

A taxa de aprendizado fixa (baixa): = 0.001, por exemplo;

O nmero de pocas de, no mnimo, 100 pocas a mais que na fase de

organizao;

Para cada padro de entrada Xk,i, faa o mesmo procedimento 5.1 e 5.2 da
fase de organizao.

3.2.1.5. FASE DE SIMULAO

Apresentar uma cor rede e verificar qual cluster venceu. Este indicar em
qual posio a pea deve ser colocada.

Deve-se relacionar cada cluster uma posio pr-definida.

4. TESTES E RESULTADOS OBTIDOS

Esta seo fala sobre os testes que foram efetuados durante o desenvolvimento do
RSC e tambm os testes finais para tal aplicao, bem como qual tipo de RNA
respondeu de melhor forma a esta. Inicialmente foram desenvolvidos trs algoritmos,
baseados nos pseudo-cdigos contidos na seo 3, sendo que estes encontram-se
nos apndices A, B e C deste trabalho.
Foram

adotados,

como

valores

para

testes,

no

momento

do

desenvolvimento do software os seguintes ndices: para a cor branca 64, para a cor
amarela 88, para a cor vermelha 91, para a cor azul 97 e para a cor preta100. Estes
valores foram obtidos atravs de uma primeira leitura pelo sensor luminoso do SRC.
Para as leituras foi utilizado o leitor de intensidade de luz para verificao
da cor incidida sobre o bloco. A Figura 25 mostra o local, circulado de vermelho,
onde feita a leitura de intensidade de luz sobre o bloco. O ideal seria usar um
sensor leitor de cores que responde de forma mais confivel no dependendo tanto
da luz ambiente.

Fig. 7: Incidncia de luz sobre o bloco no momento da leitura pelo sensor

Foram feitas, sucessivamente, 8 leituras, num mesmo ambiente,

conforme o quadro 4, onde neste quadro a sigla S/C significa que o mdulo no est
calibrado para a faixa de maior valor e C que o mdulo est calibrado, ou seja,
quando calibrado, como os valores aumentam, a hiptese de que se levantou era de
que poderia surgir melhores resultados.
Cores
Teste
Teste 01
Teste 02
Teste 03
Teste 04
Teste 05
Teste 06
Teste 07

Branco
S/C
C
62
1884
61
1868
59
1816
61
1868
61
1868
60
1805
61
1868

Amarelo
S/C
C
61
1868
60
1805
60
1805
61
1868
60
1805
58
1705
60
1805

Vermelho
S/C
C
58
1705
58
1700
59
1816
36
505
58
1700
58
1700
60
1805

S/C
37
36
36
36
58
36
60

Azul
C
515
505
505
505
1700
505
1805

Preto
S/C
C
27
63
27
47
36
505
27
47
27
47
58
1700
27
47

Teste 08

60

1805 58
1705 58
1700 36
505
Quadro 4: ndices de testes com o sensor de luz

60

1805

Aps as leituras efetuadas o que se pode observar que, ainda assim

num mesmo ambiente, o sensor de leitura de intensidade da luz poderia divergir
muito em suas leituras, podendo identificar num momento uma cor como preta e,
numa segunda leitura, a mesma cor como branca, ou seja, conforme o Teste 8 do
quadro 4, mostra que a cor branca e a preta so iguais, mesmo sendo cores de
intensidade extremas.
Ao treinar a rede Adaline usou-se taxa de aprendizado de 0.1, tolerncia
de 0.1%, mximo de pocas de 150, e 3 unidades de neurnios na camada de sada
obtendo-se um erro de 0.000095 em 134 pocas.
Os pesos encontrados no final so mostrados no Quadro 5.
Pesos obtidos ao final pelo Adaline
0,84
0,50
0,22
0,16
0,50
0,77
-0,38
-0,53
-1,40
0,12
-0,02
-1,13
-0,11
0,02
-0,86
-1,62
0,53
1,41
-0,38
-0,53
2,58
0,38
-1,47
-0,59
Quadro 5: Pesos obtidos ao final pelo Adaline

O diagnstico final do aprendizado do Adaline mostrado no Quadro 6.

Diagnstico final do aprendizado do Adaline
ENTRADAS
1
1
1
1
1

1
1
1
1
1

0
0
0
1
1

0
1
1
0
0

0
1
1
0
0

0
0
0
0
1

0
0
1
0
0

0
0
1
1
0

ALVOS
1
1
1
1
-1

1
1
-1
-1
1

1
-1
1
-1
1

SADA
1
1
1
1
1
-1
1
-1
1
1
-1
-1
-1
1
1
Quadro 6: Diagnstico final do aprendizado do Adaline

Ao treinar a rede Kohonen usou-se taxa de aprendizado de 0.95 e um

nmero de 10 cluster a unidade de sada.

Usou-se 1500 pocas na fase de organizao e 3500 pocas na fase de

refinamento dos clusters.
O Quadro 7 mostra a sada de um aprendizado realizado.
Diagnstico final do aprendizado do Kohonen
ENTRADAS
1 0 0 0 0 0 0
1 0 1 1 0 0 0
1 0 1 1 0 1 1
1 1 0 0 0 0 1
1 1 0 0 1 0 0
CLUSTERS
1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 1 1
0 0 0 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 1 0
1 1 1 0 0 0 0 0 1 0
CORES x CLUSTERS
7 9 8 0 3
Quadro 7: Diagnstico final do aprendizado do Kohonen

Ao final do desenvolvimento da aplicao observou-se que, devido a um

baixo tamanho de memria do mdulo principal do NXT (4 KB de memria flash e
512 Bytes de RAM) e, como tais aplicaes demandam uma memria maior que
esta para processamento, conseguiu-se apenas implementar o Adaline para
conexo com o RSC, conforme mostrado no apndice D. Este, obteve sucesso,
conseguindo selecionar em, praticamente todos os casos, as cores de forma correta.
Teoricamente a rede Kohonen obteve sucesso, mas o aplicativo LEGO
no suportou, a princpio, o software implementado. Portanto, para atingir-se
melhores resultados, num trabalho futuro, pretende-se fazer o uso de um leitor de
cores e tambm fazer com que o software da aplicao seja processado num
computador e no no mdulo do LEGO.

5. CONSIDERAES FINAIS
No aprendizado da rede Adaline ao usar as entradas no formato bipolar o erro
converge mais rpido do que utilizar entradas binrias. No formato bipolar o nmero
de pocas caiu para 27 gerando um erro de 0.000095.
Como o leitor de luz do RSC vulnervel iluminao ambiente, e como
a rede Adaline foi treinada com tolerncia baixa, na fase de simulao ocorreu de
cores com cdigos variados serem direcionadas erroneamente para locais diversos.
Uma opo seria trabalhar com tolerncia de erro maior na rede.
O treinamento foi feito com um cdigo de cada cor, o que poderia ser feito
um treinamento com cdigos diversos para cada cor gerando assim sadas iguais
aos alvos.
No aprendizado da rede Kohonen o uso de uma taxa de aprendizado de
0.95 mostrou-se eficiente para um nmero mnimo de 10 clusters. Desta forma as
cores foram categorizadas em clusters diferenciados o que no ocorreu quando o
nmero de clusters foi menor.
O problema da repetio de clusters para padres de classes diferentes
se deve ao fato de que os cdigos binrios de cada cor deve ser bem distinto um do
outro caracterizando classes bem diferenciadas. Uma sugesto usar cdigo Gray
ao invs de cdigo binrio nas entradas, pois, o cdigo Gray resolve o problema da
distncia de Hamming que aparece nos cdigos binrios.
Como o estudo de caso define previamente as classes de padres de
entrada a rede Adaline a princpio uma opo melhor do que a rede Kohonen,
porm, o fato de haver variao na leitura dos cdigos de cores e de estas leituras
direcionarem para uma mesma classe o uso da rede Kohonen uma opo melhor.
Na verdade por se tratar de um problema com poucos padres de
entrada, em ambas as redes a estrutura foi bem simplificada e o tempo de resposta
foi bem reduzido. Assim, ambas as redes foram satisfatrias na aplicao proposta.
Vale ressaltar que se fosse feito o uso do MLP para o RSC,
provavelmente o processamento da rede deveria ser feito num computador e desta
forma uma comunicao entre o RSC e computador seria necessrio. Nas redes
usadas processou-se tudo dentro do prprio RSC que possui de 4 KB de memria
flash e 512 Bytes de RAM.

REFERNCIAS BIBLIOGRFICAS
[1] Alecrim E. (2004) Redes Neurais Artificiais
http://www.infowester.com/redesneurais.php
[2] Braga A., Et Al (2008) Redes Neurais Artificiais Teoria e aplicaes, 2 Edio.
So Paulo. Editora LTC.
[3] Chella M. (2002) Ambiente de Robtica Educacional com Logo
http://200.169.53.89/download/CD%20congressos/2002/SBC
%202002/PDF/ARQ0009.PDF
[4] Fausett L. (1994) Fundamentals of Neural Networks, 2 edio. Prentice Hall,
New Jersey.
[5] Lego Mindstorn (2010) Tutorial Lejos NXT
http://lejos.sourceforge.net/nxt/nxj/tutorial/index.htm

APNDICES
APNDICE
KOHONEN

CODIFICAO

RNA NO-SUPERVISIONADO

Pacote da Codificao da RNA Kohonen para o RSC

51
public static void main(String args[])
52
{
53
double ent[][], w[][];
54
double taxa;
55
int vet[]={64,88,91,97,100}, max_epocas=5000, epocas=1, ncluster, r=4, j_venc=0,
j_min, j_max;
56
57
ncluster=Integer.parseInt(JOptionPane.showInputDialog("Digite o numero de
cluster:"));
58
59
w=new double[7][ncluster];
60
for(int i=0; i<7; i++)
61
for(int j=0; j<ncluster; j++)
62
w[i][j] = -0.5 + Math.random();
63
ent = converte(vet);
64
65
taxa=Double.parseDouble(JOptionPane.showInputDialog("Digite a taxa de
aprendizado:"));
66
67
while(epocas<=max_epocas)
68
{
69
double dist=100;
70
for(int k=0; k<5; k++)
71
{
72
for(int j=0; j<ncluster; j++)
73
{
74
double soma=0;
75
for(int i=0; i<7; i++)
76
soma+=Math.pow(w[i][j]-ent[k][i],2);
77
if(dist>soma)
78
{
79
j_venc=j;
80
dist=soma;
81
}
82
}
83
if((j_venc-r)<0)
84
j_min=0;
85
else
86
j_min=j_venc-r;
87
if((j_venc+r)>ncluster-1)
88
j_max=ncluster-1;
89
else
90
j_max=j_venc+r;
91
for(int i=0; i<7; i++)
92
for(int j=j_min; j<=j_max; j++)
93
w[i][j] = w[i][j] + taxa*(ent[k][i]-w[i][j]);
94
}
95
if(epocas<=1500)
96
{
if(taxa>0.1)
97
taxa=taxa*(1-epocas/5001);
98
if((r!=2)&&(epocas%(max_epocas/100)==0))
99
r--;
100
}
101
else
102
{
103
taxa=0.01;
104
r=0;
105
}
106
epocas++;
107
}
108
int w_int[][]=new int[7][ncluster];
109
for(int j=0; j<ncluster; j++)
110
for(int i=0; i<7; i++)

111
{
112
w_int[i][j]=(int)Math.round(w[i][j]);
113
w[i][j]=w_int[i][j];
114
}
115
int cores_cluster[]= new int [5];
116
for(int k=0; k<5; k++)
117
{
118
double dist=100;
119
for(int j=0; j<ncluster; j++)
120
{
121
double soma=0;
122
for(int i=0; i<7; i++)
123
soma+=Math.pow(w[i][j]-ent[k][i],2);
124
if(dist>soma)
125
{
126
j_venc=j;
127
dist=soma;
128
}
129
}
130
cores_cluster[k]=j_venc;
131
}
132
JTextArea area = new JTextArea(25,80);
133
JScrollPane barra = new JScrollPane(area);
134
String s="\t\t\t\tDIAGNSTICO\n\n ENTRADAS:";
135
136
s+="\n"+exibe(ent,5,7)+" \n\n CLUSTERS:\n"+exibe(w,7,ncluster)+" \n\n
CORESxCLUSTERS:\n\n"+mostravet(cores_cluster);
137
area.setText(s);
138
JOptionPane.showMessageDialog(null,barra,"Resultados da rede
Kohonen",JOptionPane.INFORMATION_MESSAGE);
139
System.exit(0);
140
}
141 }

Quadro 8: Pacote da Codificao da RNA Kohonen para o RSC

APNDICE B CODIFICAO RNA SUPERVISIONADO ADALINE

Pacote da Codificao da RNA Adaline para o RSC
40
41
public static String mostravet(int m[])
42
{
43
String aux="";
44
for(int i=0;i<m.length;i++)
45
{
46
aux+=m[i]+"\t";
47
}
48
return aux;
49
}
50
51
public static void main(String args[])
52
{
53
double ent[][], w[][];
54
double taxa;
55
int vet[]={64,88,91,97,100}, max_epocas=5000, epocas=1, ncluster, r=4, j_venc=0,
j_min, j_max;
56
57
ncluster=Integer.parseInt(JOptionPane.showInputDialog("Numero de cluster:"));
58
59
w=new double[7][ncluster];
60
for(int i=0; i<7; i++)
61
for(int j=0; j<ncluster; j++)
62
w[i][j] = -0.5 + Math.random();
63
ent = converte(vet);
64
65
taxa=Double.parseDouble(JOptionPane.showInputDialog("Taxa de aprendizado:"));
66
67
while(epocas<=max_epocas)
68
{
69
double dist=100;
70
for(int k=0; k<5; k++)
71
{
72
for(int j=0; j<ncluster; j++)
73
{
74
double soma=0;
75
for(int i=0; i<7; i++)
76
soma+=Math.pow(w[i][j]-ent[k][i],2);
77
if(dist>soma)
78
{
79
j_venc=j;
80
dist=soma;
81
}
82
}
83
if((j_venc-r)<0)
84
j_min=0;
85
else
86
j_min=j_venc-r;
87
if((j_venc+r)>ncluster-1)
88
j_max=ncluster-1;
89
else
90
j_max=j_venc+r;
91
for(int i=0; i<7; i++)
92
for(int j=j_min; j<=j_max; j++)
93
w[i][j] = w[i][j] + taxa*(ent[k][i]-w[i][j]);
94
}
95
if(epocas<=1500)
96
{
if(taxa>0.1)
97
taxa=taxa*(1-epocas/5001);
98
if((r!=2)&&(epocas%(max_epocas/100)==0))
99
r--;
100
}
101
else
102
{
103
taxa=0.01;
104
r=0;
105
}
106
epocas++;

107
}
108
int w_int[][]=new int[7][ncluster];
109
for(int j=0; j<ncluster; j++)
110
for(int i=0; i<7; i++)
111
{
112
w_int[i][j]=(int)Math.round(w[i][j]);
113
w[i][j]=w_int[i][j];
114
}
115
int cores_cluster[]= new int [5];
116
for(int k=0; k<5; k++)
117
{
118
double dist=100;
119
for(int j=0; j<ncluster; j++)
120
{
121
double soma=0;
122
for(int i=0; i<7; i++)
123
soma+=Math.pow(w[i][j]-ent[k][i],2);
124
if(dist>soma)
125
{
126
j_venc=j;
127
dist=soma;
128
}
129
}
130
cores_cluster[k]=j_venc;
131
}
132
JTextArea area = new JTextArea(25,80);
133
JScrollPane barra = new JScrollPane(area);
134
String s="\t\t\t\tDIAGNSTICO\n\n ENTRADAS:";
135
136
s+="\n"+exibe(ent,5,7)+" \n\n CLUSTERS:\n"+exibe(w,7,ncluster)+" \n\n
CORESxCLUSTERS:\n\n"+mostravet(cores_cluster);
137
area.setText(s);
138
JOptionPane.showMessageDialog(null,barra,"Resultados da rede
Kohonen",JOptionPane.INFORMATION_MESSAGE);
139
System.exit(0);
140
}
141 }

Quadro 9: Pacote da Codificao da RNA Adaline para o RSC

APNDICE C CODIFICAO RNA SUPERVISIONADO MULTY

LAYER PERCEPTRON
Pacote da Codificao da RNA MLP para o RSC
58
public static void main(String args[])
59
{
60
Mlp rede;
61
double ent[][], t[]={0.1,0.3,0.5,0.7,0.9};
62
double aux1[]=new double[8], aux2[]=new double[8], aux3[], aux4[];
63
double taxa, tolerancia, rms=1, erro;
64
int vet[]={64,88,91,97,100},ninter, max_epocas, epocas;
65
double z_ent[], z[], y_ent[], y[], erro_saida[], erro_inter[];
66
double v[][], w[][], pesos1[][], pesos2[][];
67
String s="";
68
taxa=Double.parseDouble(JOptionPane.showInputDialog("Taxa de aprendizado:"));
69
ninter=Integer.parseInt(JOptionPane.showInputDialog("Quantidade de neurnios na
camada intermediria?"));
70
max_epocas=Integer.parseInt(JOptionPane.showInputDialog("Numero mximo de
pocas?"));
71
tolerancia=Double.parseDouble(JOptionPane.showInputDialog("Tolerncia para o
erro?"));
72
rede = new Mlp(taxa,ninter,1);
73
rede = new Mlp(taxa,ninter,1);
74
v=rede.inicia_pesos_v();
75
w=rede.inicia_pesos_w();
76
pesos1=new double[8][ninter];
77
pesos2=new double[ninter+1][1];
78
z_ent=new double[ninter+1];
79
z=new double[ninter+1];
80
y_ent=new double[1];
81
y=new double[1];
82
erro_saida=new double[1];
83
erro_inter=new double[ninter];
84
aux3=new double[ninter+1];
85
aux4=new double[ninter+1];
86
87
epocas=1;
88
while((rms>tolerancia)&&(epocas<=max_epocas))
89
{
90
rms=0;
91
for(int i=0; i<5; i++)
92
{
93
erro=0;
94
for(int k=0; k<8; k++)
95
aux1[k]=ent[i][k];
96
z_ent[0]=aux1[0];
97
z[0]=aux1[0];
98
for(int j=0; j<ninter; j++)
99
{
100
for(int k=0; k<8; k++)
101
aux2[k]=v[k][j];
102
z_ent[j+1]=rede.somatorio(aux1,aux2);
103
z[j+1]=rede.tan_hiperbolica(z_ent[j+1]);
104
}
105
for(int k=0; k<ninter+1; k++)
106
aux3[k]=z[k];
107
for(int j=0; j<1; j++)
108
{
109
for(int k=0; k<ninter+1; k++)
110
aux4[k]=w[k][j];
111
y_ent[j]=rede.somatorio(aux3,aux4);
112
y[j]=rede.tan_hiperbolica(y_ent[j]);
113
erro+=t[i]-y[j];
114
}
115
for(int j=0; j<1; j++)
116
{
117
erro_saida[j]=(t[i]-y[j])*rede.derivada_tan_hiperbolica(y_ent[j]);
118
for(int k=0; k<ninter+1; k++)
119
pesos2[k][j]=rede.correcao_w(erro_saida[j],z[k]);
120
}

121
for(int j=1; j<ninter+1; j++)
122
{
123
for(int k=0; k<1; k++)
124
aux4[k]=w[j][k];
125
erro_inter[j-1]=rede.somatorio(erro_saida,aux4);
126
erro_inter[j-1]=rede.erro_intermed(erro_inter[j-1],z_ent[j]);
127
for(int k=0; k<8; k++)
128
pesos1[k][j-1]=rede.correcao_v(erro_inter[j-1],aux1[k]);
129
}
130
for(int j=0; j<1; j++)
131
for(int k=0; k<ninter+1; k++)
132
pesos2[k][j]=w[k][j]+pesos2[k][j];
133
for(int j=0; j<ninter; j++)
134
for(int k=0; k<8; k++)
135
pesos1[k][j]=v[k][j]+pesos1[k][j];
136
rms+=erro*erro;
137
w=pesos2;
138
v=pesos1;
139
}
140
rms=Math.pow(rms,2)/2;
141
s+="Epoca("+epocas+")"+" "+"Erro("+rms+")\n";
142
epocas++;
143
}
144
145
JTextArea area = new JTextArea(20,50);
146
JScrollPane barra = new JScrollPane(area);
147
String s1="PESOS CAMADA INTERMEDIARIA:", s2="PESOS CAMADA SAIDA:", s3="";
148
149
for(int i=0;i<8;i++)
150
{ s1+="\n";
151
for(int j=0;j<ninter;j++)
152
s1+=v[i][j]+"\t";
153
}
154
for(int i=0;i<ninter+1;i++)
155
{ s2+="\n";
156
for(int j=0;j<1;j++)
157
s2+=w[i][j]+"\t";
158
}
159
s3+=s+"\n\n"+s1+"\n\n"+s2;
160
area.setText(s3);
161
JOptionPane.showMessageDialog(null,barra,"Resultados do
MLP",JOptionPane.INFORMATION_MESSAGE);
162
System.exit(0);
163
}
164 }

Quadro 10: Pacote da Codificao da RNA MLP para o RSC

APNDICE D CODIFICAO DO ADALINE ADAPTADA AO RSC

Pacote da Codificao da RNA Adaline adaptada ao RSC
package adaline;
import lejos.nxt.LCD;
import lejos.nxt.LightSensor;
import lejos.nxt.Motor;
import lejos.nxt.SensorPort;
import lejos.nxt.Sound;
import lejos.nxt.TouchSensor;
public class AdalineLego {
public static int NUM_NEURONIOS = 10;
public static void main(String args[]) throws InterruptedException {
LightSensor lightSensor = new LightSensor(SensorPort.S1);
TouchSensor touchSensor = new TouchSensor(SensorPort.S3);
double ent[][], t[][] = { { 1, 1, 1 }, { 1, 1, -1 }, { 1, -1, 1 },
{ 1, -1, -1 }, { -1, 1, 1 } };
double aux1[] = new double[NUM_NEURONIOS + 1], aux2[] = new double[NUM_NEURONIOS + 1];
double taxa, tolerancia, rms = 1, err = 0, yent;
int nneuron, max_epocas, epocas;
int vet[] = new int[5];
for (int i = 0; i < vet.length; i++) {
int leitura;
while (true) {
leitura = lightSensor.readNormalizedValue();
LCD.clear();
LCD.drawString("leitura " + i, 1, 1);
LCD.drawInt(leitura, 2, 2);
Thread.sleep(500);
if (touchSensor.isPressed()) {
Sound.beep();
break;
}
}
vet[i] = leitura;
}
double y_ent[], y[][], erro[], w[][];
String s = "";
ent = converte(vet);
// 0.1
taxa = 0.1;
// 3
nneuron = 3;
// 1500
max_epocas = 1500;
// 0.025
tolerancia = 0.015;
w = inicia_pesos_w(nneuron);
y_ent = new double[nneuron];
y = new double[NUM_NEURONIOS + 1][nneuron];
erro = new double[nneuron];
// treinamento
epocas = 1;
while ((rms > tolerancia) && (epocas <= max_epocas)) {
rms = 0;
for (int i = 0; i < 5; i++) {
for (int k = 0; k < NUM_NEURONIOS + 1; k++)
aux1[k] = ent[i][k];
err = 0;
for (int j = 0; j < nneuron; j++) {
for (int k = 0; k < NUM_NEURONIOS + 1; k++)
aux2[k] = w[k][j];
y_ent[j] = somatorio(aux1, aux2);
erro[j] = t[i][j] - y_ent[j];
err += erro[j] * erro[j];
for (int k = 0; k < NUM_NEURONIOS + 1; k++)
w[k][j] = w[k][j] + taxa * (t[i][j] - y_ent[j])
* aux1[k];
}
rms += err * err;
}
rms = rms / 2;

s += "Epoca(" + epocas + ")" + " " + "Erro(" + rms + ")\n";

epocas++;
}
// rede em funcionamento
while (true) {
int leitura;
leitura = lightSensor.readNormalizedValue();
LCD.clear();
double[] leituraConvertida = converte(leitura);
double[] saida = new double[nneuron];
for (int j = 0; j < nneuron; j++) {
for (int k = 0; k < NUM_NEURONIOS + 1; k++)
aux2[k] = w[k][j];
yent = somatorio(leituraConvertida, aux2);
if (yent >= 0)
saida[j] = 1;
else
saida[j] = -1;
}
String saidaStr = "" + saida[0] + saida[1] + saida[2];
LCD.clear();
LCD.drawString(saidaStr, 4, 3);
// preto
if ("1.01.01.0".equals(saidaStr)) {
LCD.drawString("Cor[" + leitura + "] preto", 2, 2);
} else {// azul
if ("1.01.0-1.0".equals(saidaStr)) {
LCD.drawString("Cor[" + leitura + "] azul", 2, 2);
} else {// vermelho
if ("1.0-1.01.0".equals(saidaStr)) {
LCD.drawString("Cor[" + leitura + "] vermelho", 2, 2);
} else {// amarelo
if ("1.0-1.0-1.0".equals(saidaStr)) {
LCD
.drawString("Cor[" + leitura + "] amarelo",
2, 2);
}
if ("-1.01.01.0".equals(saidaStr)) {
LCD.drawString("Cor[" + leitura + "] branco", 2, 2);
} else {
LCD.drawString("Cor[" + leitura
+ "] nao identificada releitura", 2, 2);
}
}
}
}
Thread.sleep(2000);
}
}
public static double[][] converte(int a[]) {
int b, c;
int rest[] = new int[NUM_NEURONIOS];
double aux[][] = new double[a.length][NUM_NEURONIOS + 1];
for (int i = 0; i < a.length; i++) {
b = a[i];
int j = 0;
do {
c = b / 2;
rest[j] = b % 2;
j++;
b = c;
} while (c != 1);
rest[j] = c;
aux[i][0] = 1;
for (int k = j; k >= 0; k--) {
if (rest[k] == 0)

aux[i][NUM_NEURONIOS - k] = -1;
else
aux[i][NUM_NEURONIOS - k] = 1;
}
}
return aux;
}
public static double[] converte(int b) {
int c;
int rest[] = new int[NUM_NEURONIOS];
double aux[] = new double[NUM_NEURONIOS + 1];
int j = 0;
do {
c = b / 2;
rest[j] = b % 2;
j++;
b = c;
} while (c != 1);
rest[j] = c;
aux[0] = 1;
for (int k = j; k >= 0; k--) {
if (rest[k] == 0)
aux[NUM_NEURONIOS - k] = -1;
else
aux[NUM_NEURONIOS - k] = 1;
}
return aux;
}
public static double[][] inicia_pesos_w(int nneuron) {
double w[][] = new double[NUM_NEURONIOS + 1][nneuron];
for (int i = 0; i < NUM_NEURONIOS + 1; i++)
for (int j = 0; j < nneuron; j++)
w[i][j] = -0.5 + Math.random();
return w;
}
public static double somatorio(double entrada[], double pesos[]) {
double result = 0;
for (int i = 0; i < entrada.length; i++)
result += entrada[i] * pesos[i];
return result;
}
}

Quadro 11: Pacote da Codificao da RNA Adaline adaptada ao RSC