Inteligência Artificial

Tenho estado um pouco ocupado e sem tempo para realizar os posts, mas vamos dar continuidade.

No post anterior vimos o funcionamento de uma Rede Neural Hopfield para reconhecimento de padrões, entretanto, notamos uma matriz de Peso, que já estava pronta para reconhecer os valores de entrada 1010 e 0101. Como chegamos naqueles valores da matriz?

Começamos então como uma matriz de peso em branco, como segue abaixo:

Tendo uma matriz inicial, treinaremos ela para reconhecer os padrões 0101, então para isso, calcularemos uma matriz para a entrada 0101, a qual é chamada de matriz de contribuição 0101.

Após calcular essa matriz de contribuição 0101, o resultado é adicionado a matriz de peso em branco, se quisermos que ela também reconheça o padrão 1110, então calcularemos a matriz de contribuição 1110 e também iremos adicionar a matriz de peso.

Lembramos que com as redes neurais Hopfield, teremos então uma Rede Neural que será capaz de reconhecer os padrões 0101 e 1110, e também, os complementos destes (1010 e 0001).

Para calcular a Matriz de Contribuição 0101 seguiremos três passos:

1. Calcular os valores bipolares de 0101, ou seja transformar 0101 em -1,1,-1,1;
2. Transpor o equivalente bipolar de 0101 e multiplicar por ele mesmo;
3. E ajustar os valores da diagonal principal do resultado para 0.

Esse último, pois os neurônios não tem conexões entre si mesmos, nas redes neurais Hopfield. Lembremos, do último post, que a Matriz de Peso nas redes neurais Hopfield são na verdade os pesos dos neurônios ligados a cada outro neurônio.

Vamos começar então do primeiro passo, segundo Heathon, é necessário converter os valores binários para bipolar, pois “0 não é o contrário de 1, preferivelmente -1 é o inverso matemático de 1.”

Já temos a classe bipolarutil, que contém métodos necessários para a conversão, agora, matematicamente falando, a conversão pode ser dada através das seguintes equações.

Para o passo 2, necessitaremos multiplicar o vetor anterior pela sua transposição, sendo então o seguinte:

X

Com essa multiplicação, obteremos como resultado a seguinte matriz:

Agora é o momento de utilizar o passo 3, ajustar o valor da diagonal principal para 0, para efeitos matematicos fazemos isso diminuindo da matriz de contribuição a Matriz Identidade, e o resultado será:

Com nossa matriz de contribuição pronta, tudo que temos a fazer agora é adicionar essa matriz de contribuição 0101 à Matriz de Peso da Rede Neural. E caso queiramos que nossa rede também reconheça o padrão 1001, iremos fazer os mesmos procedimentos deste post e no final adicionar à matriz de Peso, que já terá a Matriz de Contribuição 0101.

No próximo post, iremos ver isso na prática, os exemplos de Jeff Heathon, que você pode olhar no site do mesmo, ao lado.

 

 

Vamos ver um exemplo de Rede Neural Hopfield com quatro neurônios, cada neurônio é conectado aos outros três neurônios, formando assim, um total de 12 conexões.

 

Na aplicação de redes neurais usaremos matrizes para armazenar os pesos das conexões, todas as redes neurais utilizam alguma forma de matriz para armazenar os pesos.

 

A matriz acima é chamada de matriz Peso e contém a memória da rede neural, utilizada para reconhecer padrões, quando eles forem mostrados.

Geralmente as matrizes também armazenam os valores de limiar, entretanto, Redes Neurais Hopfield não contém tais valores.

As valores utilizados na próxima tabela são utilizados para que uma rede reconheça os valores 0101 e 1010, vamos ver como funciona.

 Mostraremos a rede o valor 0101, para isso, alimentaremos cada neurônio de entrada, que também é de saída, com o valor 0101.

Quando o neurônio 1 (N1) for alimentado com 0101, sua ativação resultará na soma de todos os pesos que terão 1 no padrão de entrada.

Vejamos os pesos do N1:

 

Agora os pesos comparados ao padrão de entrada.

 

Como dito anteriormente, a ativação do neurônio será a soma dos pesos cujo valor de entrada seja 1, logo:

N1 = (-1) + (-1) = (-2)

N2 = (0) + (1) = (1)

N3 = (-1) + (-1) = (-2)

N4 = (1) + (0) = (1)

O vetor final de saída será {-2, 1, -2, 1}, para funcionar precisaremos de uma função de ativação, um limiar dirá quando um neurônio irá queimar, logo o limiar é uma função de ativação.

Numa rede neural Hopfield, dizemos que a função de ativação é qualquer valor maior que zero, logo, está estabelecido o limiar da nossa rede e os seguintes neurônios irão queimar.

N1 = (-2) – não queimará.

N2 = (1) – queimará.

N3 = (-2) – não queimará.

N4 = (1) – queimará.

Para os neurônios que não queimarem assume-se o valor de 0 e para os neurônios que queimaram o valor  de 1, logo a saída da nossa rede será 0101.

Uma rede que reconhece o padrão 0101, também reconhece o valor 1010.

 

Vamos ver uma utilização de redes neurais artificiais com camadas ocultas.

O exemplo a seguir, é uma demonstração de uma rede que reconhece uma porta lógica XOR.

Acima temos a tabela verdade da porta lógica XOR.

Para fazermos uma rede neural reconhecer uma porta lógica XOR, precisaremos de três camadas, uma camada de entrada, contendo dois neurônios, uma camada de saída contendo o resultado (V ou F) e uma camada central, a camada oculta.

Vejamos o exemplo a seguir:

Cada neurônio da camada de entrada é ligado aos dois neurônios da camada oculta e os dois neurônios da camada oculta é ligado a camada de saída.

Agora veremos como funciona:

Caso o neurônio 1 receba entrada 0 e o neurônio 2 receba entrada 1,  o neurônio 1 recebe 0 que multiplicado aos pesos 1, resulta em 0, o neurônio 2 recebe 1 que multiplicado aos pesos 1, resulta em 1.

Esse resultado 1 somado ao resultado 0 do primeiro neurônio é insuficiente para queimar a ligação no primeiro neurônio da camada oculta, mas é suficiente para queimar o segundo neurônio na camada oculta, pois este tem limiar de 0.5.

O peso do primeiro neurônio da camada oculta é -1,  como ele não foi queimado então será 0, que será somado ao peso do segundo neurônio da camada oculta, que foi queimado, resultando em 1.

A camada oculta terá saída de 0 + 1 = 1 no neurônio de saída que possui limiar de 0.5, logo o neurônio de saída queimará, fazendo com que o resultado de 0 e 1 seja 1.

Agora veremos a mesma rede para a entrada 1 xor 1, primeiro neurônio receberá entrada 1 e o segundo também.

Logo o primeiro neurônio da camada oculta queimará, pois a ligação dos dois neurônios de entrada excede o limiar 1.5 e o segundo neurônio da camada oculta também, pois o limiar deste é 0.5.

Entretanto o peso do primeiro neurônio da camada oculta é -1 e do segundo neurônio da camada oculta é 1, logo -1+1 = 0, que não é suficiente para queimar o neurônio de saída, pois o limiar é 0.5, logo 1 xor 1 = 0.

Esse exemplo e os outros são muito simples, mas com eles podemos ter uma noção do funcionamento das redes neurais, de duas camadas e de três ou mais camadas.

Esses exemplos funcionarão como um programa “Hello World!” para redes neurais.

No próximo post veremos exemplo das Redes Neurais Hopfield, que são redes neurais utilizadas para reconhecimento de padrão, onde os neurônios de entrada são, também, neurônios de saída.

Até mais

Acima temos a tabela verdade para a operação E, que mostra que a saída só é verdadeira quando ambas as entradas também o são.

Agora para construir uma rede neural que reconheça essa porta lógica, precisaremos de três neurônios, dois de entrada e um de saída.

Vejamos o exemplo acima, temos duas entradas com peso 1 e um neuronio de saída com limiar 1,5. O que acontecerá é o seguinte: se a entrada no neurônio 1 for 1 e no neurônio 2 for 0, então a entrada 1 multiplicado pelo peso 1 e a entrada 0 multiplicada pelo peso 1 resultará em 1, que não excederá o valor de limiar 1.5 e o neurônio não queimará.

Agora, se a entrada no neurônio 1 for 1 e no neurônio 2 for 1, multiplicando pelos pesos, resultará no valor 2, que excederá o valor de limiar 1.5, e resultará com que o neurônio de saída queime.

Vamos agora fazer uma rede neural para o operador lógico OU, a tabela verdade do operador pode ser vista abaixo.

Agora vamos a rede neural para o operador lógico OU.

 

A única diferença da rede neural do operador E para o operador OU é o valor de limiar, como no operador ou o resultado só será falso se ambas as entradas forem falsas, o valor de limiar é 0.9.

Se a entrada no neurônio 1 for 1 e no neuronio 2 for 0, então a multiplicação da primeira entrada pelo peso 1 e da segunda entrada pelo peso 1 resultará em 1, que vai exceder o valor de limiar 0.9, queimando assim, o neurônio de saída.

Agora se a entrada no neurônio 1 for 0 e no neurônio 2 for 0, então a primeira entrada multiplicada pelo peso e a segunda entrada multiplicada pelo peso resultará em 0. Valor insuficiente para que o neurônio de saída queime.

Esses exemplos são simples, vimos acima exemplos apenas com camadas de entrada e saída, mas poderemos ter também redes neurais com camadas ocultas.

Para trabalharmos com redes neurais, precisaremos de matrizes para criar as matrizes de pesos e de uma forma de operar sobre essas matrizes, essa forma é a classe MatrixMath, com essa classe podemos fazer operações comuns as matrizes, tais como adição/subtração de matrizes, multiplicação de matrizes e multiplicação por escalar, cálculo do produto escalar, transposição, entre outras.

Só então com essas duas classes e com a classe bipolarutil, que poderemos começar a trabalhar com as redes neurais.

Nesse post adiciono mais uma classe e uma apresentação em slides sobre a classe MatrixMath, pode ser visto no site do Jeff Heaton a versão completa dessa classe, eu resumi apenas os métodos que iremos utilizar para trabalhar com redes neurais.

Para acessar os slides e a classe entre na pasta Matriz.

Demorei mas terminei, fiquei alguns dias parado pois estava elaborando slides sobre a classe Matrix. Essa classe utilizaremos para trabalhar com matrizes em Java. Ela possui métodos para clonar, criar, modificar, limpar e manusear de diversas formas matrizes. Com essa classe podemos trabalhar com matrizes tanto uni-dimensionais (vetores) como bi-dimensionais.

Os slides estão em power point 2007 e possuem detalhes explicativos, e exemplos dos métodos.

O conteúdo utilizado foi do site de Jeff Heaton sobre Redes Neurais, futuramente abordarei esse assunto.

Comentem sobre os slides e testem aí, junto posto três arquivos de classes java: a classe MatrixError, que contém o tratamento de exceções envolvendo matrizes, e a classe BiPolarUtil que serve para conversão de números booleanos para bi-polar e vice-versa, todas essas classes serão utilizadas em breve.

Os slides e códigos Java estão na pasta Matriz, para acessá-los clique aqui.

Nesse primeiro post, quero apenas descrever o meu interesse em difundir inteligência artificial, em especial as Redes Neurais Artificiais. Ensinar e aprender junto com os que se interessam pela área, ou por qualquer outra da informática.

No momento só isso, depois, vou colocar exemplos em Java e depois em outras linguagens. Também vou colocar a tradução de alguns capítulos do livro de Jeff Heaton sobre o assunto.

Até mais e bons estudos.