Biblioteca Joone (Java-Oriented-Object-Engine)

Criado por Paolo Maronne

Conceito

Cada rede neural (RN) é composta de um número de componentes (camadas) unidas

por conexões (sinapses). Dependendo de como esses componentes são conectados, muitas
arquiteturas de redes neurais podem ser criadas (feed forward RN, recurent RN, etc).

Figura 1 - Exemplo de rede feed-forward retirado da documentação do JOONE

Cada camada (layer) processa o sinal de entrada através da aplicação de uma função
de transferência e envia o padrão resultante para as sinapses que a ligam com a camada
seguinte. Dessa forma, uma rede neural pode processar um padrão de entrada, transferindo-o
da camada de entrada para a camada de saída. Este é o conceito básico sobre o qual o motor
inteiro foi baseado. Para garantir que é possível construir qualquer arquitetura de rede neural
com o Joone, um método para transferir os padrões através da rede sem um ponto central de
controle é requerido. Par alcançar esse objetivo, cada camada do Joone é implementada como
um objeto Runnable, de modo que cada camada roda independentemente das outras camadas
(recebendo o padrão de entrada, aplicando-o a função de transferência e colocando o padrão
resultante nas sinapses de saída para que as próximas camadas possam recebê-lo, processá-lo
e assim por diante) como representado pelo seguinte esquema básico:
Onde para cada neurônio N:

XN – The weighted net input of each neuron = (I1 * WN1) + … + (IP * WNP)

YN – O valor de saída de cada neurônio = f(XN)

f(X) – A função de transferência (depende do tipo da camada)

Esse mecanismo de transporte também é usado para transportar o erro das camadas
de saída para as camadas de entrada durante a fase de treinamento, permitindo que os pesos
e vieses (bias) sejam alterados de acordo com o algoritmo de treinamento escolhido (por
exemplo, o algoritmo de retro propagação). Em outras palavras, o objeto camada
alternadamente “injeta” o sinal de entrada pelas sinapses de entrada até as sinapses de saída,
e o padrão de erro pelas sinapses de saída até as sinapses de entrada. Para Alcançar isso, cada
camada tem dois mecanismos de transporte opostos, um para transferir da entrada para a
saída, o padrão de entrada durante a fase de “recall”, e outro para transferir da saída para a
entrada o erro de aprendizagem durante a fase de treinamento, como representado pela
seguinte figura:

Cada componente do Joone (ambos, camadas e sinapses) tem seu próprio (pré
construído) mecanismo para ajustar os pesos e vieses (bias) de acordo com o algoritmo de
treinamento escolhido. Arquiteturas de redes neurais complexas podem ser facilmente
construídas, sejam linear ou recursiva, porque não há necessidade de um controlador global
para a rede. Imagine cada camada como um tubo que “empurra” o sinal (padrão) da entrada
para a saída, onde uma ou mais sinapses conectam-na com as próximas camadas,
independente do numero de entradas, da seqüência ou do numero de camadas conectadas.
Essa é a principal característica do Joone, garantido pelo fato de cada camada rodar no seu
próprio Thread, representando o elemento ativo único de uma rede neural com base no
mecanismo principal do Joone. Observe a figura seguinte (as setas representam as sinapses):
Camadas

O objeto “camada“ é o objeto básico que forma a rede neural. É composto por
neurônios, todos tendo as mesmas características. Esse componente “transfere” o padrão de
entrada para o padrão de saída executando uma função de transferência. O padrão de saída é
eviado para um vetor de objetos “sinapses” ligado as camadas de saída. É o elemento ativo de
uma rede neural no Joone, na verdade ele roda em uma Thread separada (que implementa a
interface Java.lang.Runnable) de forma que possa rodar independente das outras camadas da
rede neural.

Tipos de camadas (Layers): Linear Layer, Sigmoid Layer, Tanh Layer, Logarithmic Layer, Delay
Layer, Context Layer, WinnerTakeAll Layer e Gaussian Layer.

Sinapses

A “sinapse” representa a conexão entre duas camadas, permitindo um padrão passar

de uma camada para a outra. A sinapse é também a memória de uma rede neural. Durante o
processo de treinamento o peso de cada conexão é modificado de acordo com o algoritmo de
treinamento. Lembre que, como descrito anteriormente, uma sinapse é, ambos, a sinapse de
saída de uma camada e a sinapse de entrada da próxima camada conectada na RN, portanto,
representa um recurso compartilhado entre duas camadas (não mais do que dois, porque uma
sinapse pode estar ligada somente à entrada ou à saída de uma camada).

Para evitar que uma camada tente ler o padrão de suas sinapses de entrada antes
que outras camadas possam escrevê-lo, a sinapse é compartilhada com sincronização; em
outros termos, um mecanismo baseado em semáforo previne que duas camadas acessem
simultaneamente uma sinapse compartilhada.

Tipos de sinapses: Direct Synapse, Full Synapse, Delayed Synapse, Kohonen Synapse e Sanger
Synapse
O Monitor

Obviamente uma rede neural não pode ser composta somente pelos dois tipos de
elementos de processamento acima – camadas e sinapses – porque existe a necessidade de
controlar todos os parâmetros de interesse no processo de execução e/ou treinamento. Por
esse motivo o motor é composto por muitos outros componentes concebidos para fornecer à
rede neural uma serie de serviços. O principal componente que está sempre presente em
cada rede neural baseada no Joone o objeto Monitor. Ele representa o ponto central no com o
qual estão contidos todos os parâmetros que outros componentes precisam para funcionar
corretamente, como a taxa de aprendizagem, o momento, o número de épocas de
treinamento, o ciclo de treinamento atual, etc. Cada componente de uma rede neural (ambos,
camadas e sinapses) recebem um ponteiro para uma instância do objeto monitor. Essa
instância pode ser diferente para cada componente, mas usualmente só uma única instância é
criada e usada, de modo que cada componente pode acessar os mesmos parâmetros em toda
a rede neural, como ilustrado na figura a seguir:

Dessa maneira, quando o usuário quer mudar algum desses parâmetros, ele/ela pode
o valor correspondente no objeto Monitor; como resultado cada componente da rede neural
irá receber o novo valor para o parâmetro alterado. O monitor provê serviços não somente
para os componentes internos de uma rede neural, mas também para a aplicação externa que
o utiliza. O objeto monitor, na realidade, abastece qualquer aplicação externa com um
mecanismo de notificação baseado em diversos eventos que surgem quando uma ação
particular é executada. Por exemplo, uma aplicação externa pode ser avisada quando a rede
neural iniciar ou parar as épocas de treinamento, quando terminar um ciclo ou quando o valor
do erro global (o RMSE) mudar durante a fase de treinamento. Dessa maneira qualquer
aplicação usando o Joone pode assincronamente realizar certa ação em resposta a um evento
especifico da rede neural controlada, por exemplo, para o treinamento quando um baixo
RMSE é alcançado, ou checar o nível de generalização da rede usando um conjunto de
validação separado, ou mostrar em alguma janela gráfica os valores atuais dos parâmetros da
rede, etc... A seguir, uma lista dos recursos do objeto Monitor.

O Monitor contêm todos os pâmetros necessários durante as fases de treinamento, e.g. a taxa
de treinamento, o momento, etc. Cada parâmetro tem seus próprio método “get” e “set”,
conforme as especificações JavaBeans. Esses parâmetros podem ser usados por uma aplicação
externa, para por exemplo, mostrá-los em uma interface de usuário, ou para um componente
interno calcular as fórmulas que implementam a chamada das fases de recall/treinamento,
representando nesse sentido um padrão e um mecanismo centralizado para definir ou
recuperar os parâmetros necessários para o trabalho. O objeto Monitor é também um ponto
central para controlar o inicio/parada da rede neural.

Antes de explicar como isso funciona, uma explicação é querida sobre o como os componentes
de entrada da rede funcionam. Quando a primeira camada de uma rede neural chama a
componente sinapse de entrada pedindo um padrão de uma fonte externa, essa componente
chama o Monitor para avisar que um novo ciclo deve ser iniciado. O monitor, de acordo com
seu estado interno ( ciclo atual, época atual, etc.), verifica se o próximo padrão de entrada
pode ser processado normalmente. Se sim, a sinapse de entrada simplesmente recebe
permissão para continuar a preparar o próximo padrão, e todos os contadores internos do
Monitor são atualizados. Se não (i. e. a rede alcançou a última época), o objeto Monitor não dá
permissão para continuar e também notifica todas as aplicações externas criando um evento
que descreve a natureza da notificação. Dessa maneira os seguintes serviços estão disponíveis
ao utilizar o objeto Monitor:

1. A sinapse de entrada sabe se pode ler e processar o próximo padrão ( caso contrário ela
para), sendo avisada por um valor de retorno booleano.

2. Uma aplicação externa pode iniciar/parar uma rede neural simplesmente definindo os
parâmetros iniciais do Monitor. Para simplificar essas ações, algums métodos simples – Go
iniciar), Stop (parar) e runAgain (para reiniciar uma rede neural perviamente parada) – foram
adicionados ao Monitor.

3. Os objetos observadores (e.g. a aplicação principal) conectados ao Monitor podem ser

avisados quando um evento particular surgir, como quando uma época ou todo o processo de
treinamento terminar ( por exemplo, mostrar ao usuário a época atual de treinamento ou o
atual erro de treinamento). Para ver como gerenciar os eventos do Monitor para ler os
parâmetros de uma rede neural leia o parágrafo seguinte.
Biblioteca Neuroph (Java-Oriented-Object-Engine)

Criado por Paolo Maronne

Conceito