Class Shift begin
{Entradas: E - conjunto de treinamento com n instâncias da forma: (‘xk0’, xk1, xk2,..., xkp, Ck), sendo que 1 ≤ k ≤ n
MAX - número máximo de neurônios intermediarios da rede, pre-determinado} {Saída: objeto shift que representa a rede neural criada}
camadaMax ← MAX
nroNeuronios ← 0 {conta número de neurônios na camada intermediária}
Camada[camadaMax] {vetor formado por neurônios intermediários}
method Shift (Matrix E) begin
precisaoAnteiror ← 0
saida ← new Neuronio(E) precisao ← precisao() erroPositivo ← erroPositivo() erroNegativo ← erroNegativo()
while (precisao > precisaoAnterior and precisao ≠ 1 and nroNeuronios ≤ camadaMax) do begin
if erroPositivo ≥ erroNegativo then begin
Epos ← criaTreinamentoPositivo()
Camada[nroNeuronios] ← new Neuronio(Epos) corrigePositivo()
end
else if erroNegativo > erroPosivivo then begin
Eneg ← criaTreinamentoNegativo()
Camada[nroNeuronio] ← new Neuronio(Eneg) corrigeNegativo() end precisao ← precisao() nroNeuronio ← nroNeuronio +1 erroPositivo ← erroPositivo() erroNegativo ← erroNegativo() end end {method} end {Class}
Capítulo 5 - O Algoritmo Shift
73
5.2.1 Exemplo de Execução do Algoritmo Shift usando o Algoritmo PMR
Como comentado na Seção 5.1, para exemplificar o funcionamento do algoritmo Shift, será usado o conjunto de treinamento que representa o conceito de Paridade-3 ímpar, mostrado na Tabela 5.1 com a adição do termo bias.
O primeiro passo do algoritmo é treinar o neurônio de saída. Como o conjunto não é linearmente separável o vetor de pesos W0 não classifica corretamente todos os exemplos do
conjunto de treinamento. Seja W0 = 〈1 1 1 –1〉, o vetor de pesos obtido no treinamento do
neurônio de saída. Esse vetor comete dois erros, um erro de negativo em E2 e um erro de positivo em E7. Como não houve um tipo de erro predominante, o erro de positivo é tratado primeiro. A Tabela 5.1 apresenta o conjunto de treinamento e os resultados dos vk para 1 ≤ k ≤ n da rede atual.
Tabela 5.1 – Conjunto que representa o problema Paridade-3 e os valores de vk (k = 1,...,8)da rede atual Exemplos Ek (k = 1,...,8) X0(bias) X1 X2 X3 Classe vk (k = 1,...,8) E1 1 1 1 1 1 2 E2 1 1 1 –1 –1 4 E3 1 1 –1 1 –1 0 E4 1 1 –1 –1 1 2 E5 1 –1 1 1 –1 0 E6 1 –1 1 –1 1 2 E7 1 –1 –1 1 1 –2 E8 1 –1 –1 –1 –1 0
Como neste caso o erro de positivo será tratado primeiro, o algoritmo deve inserir um neurônio intermediário u1 para corrigir os erros de positivo. Como mencionado anteriormente,
para treinar um neurônio que deve corrigir erros de positivo, são usados os exemplos que geram vk ≤ 0 na rede atual.
O conjunto de treinamento do novo neurônio, u1 é mostrado na Tabela 5.2. O
treinamento de u1 resulta no vetor de pesos W1 = 〈–1 –1 –1 1〉. Tal vetor de pesos classifica
corretamente todos os exemplos de treinamento da Tabela 5.2.
Tabela 5.2 – Conjunto de treinamento do neurônio alocado para corrigir erros de positivo Exemplos Ek (k = 3, 5, 7, 8) X0 (bias) X1 X2 X3 Classe Ck (k = 3, 5, 7, 8) E3 1 1 –1 1 –1 E5 1 –1 1 1 –1 E7 1 –1 –1 1 1 E8 1 –1 –1 –1 –1
Capítulo 5 - O Algoritmo Shift
74 O próximo passo do algoritmo é chamar o método corrigePositivo() que tem como função escolher um peso ∆ que minimize os erros da rede. Para a escolha de ∆, é necessário identificar os vks, com 1 ≤ k ≤ n, para os quais a instância correspondente Ek produza k
1
O = 1 (ver Tabela 5.3). Nesse caso a única opção de valores de vk é v7 = –2. Como o neurônio a ser adicionado é para corrigir erros de positivo, ∆1 = –1(vk – δ). Para este exemplo foi usado
δ = 0,5 e, portanto, ∆1 = 2,5.
Depois de adicionado um neurônio, a rede verifica se ainda comete erro ou se algum critério de parada foi satisfeito, por exemplo, se a rede comete mais erros que cometia antes da inserção do último neurônio. Se nenhum critério de parada for satisfeito, o conjunto vk é recalculado e o treinamento continua. A Tabela 5.3 mostra as saídas do neurônio u1 e os
novos valores de vk para 1 ≤ k ≤ n.
Tabela 5.3 – Conjunto com as classes originais saída de O1 e novos valores de vk (k = 1,..., 8)
Exemplos Ek (k = 1,..., 8) O1 Classe Ck (k = 1,..., 8) vk (k = 1,... 8) E1 –1 1 2 E2 –1 –1 4 E3 –1 –1 0 E4 –1 1 2 E5 –1 –1 0 E6 –1 1 2 E7 1 1 0,5 E8 –1 –1 0
Como a rede melhora sua precisão, o processo de inserção de neurônios intermediários continua. A rede atual comete um erro de negativo, na instância E2. Para corrigir este erro o algoritmo cria o neurônio u2. Como este neurônio foi alocado para corrigir erros de negativo,
as instâncias usadas para treiná-lo serão todas Ek instâncias que geram vk > 0 para 1 ≤ k ≤ n com suas classes invertidas, como mostra a Tabela 5.4.
Tabela 5.4 – Conjunto de treinamento do neurônio alocado para corrigir erros de negativo Exemplos Ek (k = 1, 2, 4, 6, 7) X0 (bias) X1 X2 X3 Classe Ck (k = 1, 2, 4, 6, 7) E1 1 1 1 1 –1 E2 1 1 1 –1 1 E4 1 1 –1 –1 –1 E6 1 –1 1 –1 –1 E7 1 –1 –1 1 –1
O treinamento do neurônio u2 com o conjunto de treinamento da Tabela 5.4 resulta no
Capítulo 5 - O Algoritmo Shift
75 é calcular o valor de ∆2. Para o caso de erros de negativo o ∆ escolhido deve ser o maior
dentre os valores de vk com 1 ≤ k ≤ n associados a Ek, que ativem o último neurônio adicionado, i.e. O = 1. k2
Neste caso a única instância que ativa o neurônio u2 é a instância E2, assim o único
valor que pode ser escolhido é v2 = 4. Como o ∆ para erros de negativo é dado por (5.4), tem- se ∆2 = –4,5. A configuração da rede recém obtida, mostrada na Figura 5.2, classifica
corretamente todos os exemplos de treinamento.
Figura 5.2 – Conceito de Paridade-3 aprendido por uma rede Shift que usa o PMR para treinar TLUs
Note que a solução para o problema de Paridade-3 resolvida pelo Shift envolveu dois neurônios intermediários. De fato, em [Amaldi & Guenin 1998] pode ser encontrada a prova de que todo problema de Paridade-n pode ser resolvido pelo algoritmo Shift por meio da criação de uma rede com 1
2 1 n − + neurônios intermediários.
5.2.2 Exemplo de Execução do Algoritmo Shift usando o Algoritmo
BCPMin
Considere o problema de Paridade-3, apresentado anteriormente e o conjunto de treinamento, porém sem a adição do termo bias, mostrado na Tabela 5.5. Suponha que o treinamento do neurônio de saída pelo BCPMin com o conjunto da Tabela 5.5 resulte no vetor de pesos W0 = 〈10 –9,1 11,4〉 e bias θ0 = 0. O hiperplano definido por esse vetor e este bias
X0 (bias) X2 2.5 –4.5 X3 X1 u1 u2
Capítulo 5 - O Algoritmo Shift
76 comete dois erros de classificação, um erro de positivo em E6 e um erro de negativo em E3. A Tabela 5.5 mostra também os valores de vk para 1 ≤ k ≤ 8 da rede atual.
Tabela 5.5 – Conjunto de treinamento paridade-3 com os valores de vk (k = 1,..., 8) para a rede atual
Exemplos Ek (k = 1,..., 8) X1 X2 X3 Classe Ck (k = 1,..., 8) vk (k = 1,..., 8) E1 1 1 1 1 12,3 E2 1 1 –1 –1 –10,4 E3 1 –1 1 –1 30,4 E4 1 –1 –1 1 7,7 E5 –1 1 1 –1 –7,7 E6 –1 1 –1 1 –30,4 E7 –1 –1 1 1 10,4 E8 –1 –1 –1 –1 –12,3
Como a rede comete dois erros, um de cada tipo, o erro de positivo é tratado primeiro. O conjunto de treinamento usado para treiná-lo será formado pelas instâncias do conjunto de treinamento original que geram vk ≤ 0, para 1 ≤ k ≤ n. Desse modo, as instâncias usadas no treinamento do novo neurônio u1, serão as instâncias E2, E5, E6 e E8.
Suponha que o treinamento do neurônio u1 tenha resultado no vetor de pesos
W1 = 〈–0,6 0,73 –0,72〉 e bias θ1 = –1,5. Como este hiperplano separa somente a instância E6
das outras instâncias, o peso da conexão será ∆1 = 30,9. A Tabela 5.6 mostra as saídas do
neurônio u1 e os valores de vk, com 1 ≤ k ≤ 8, atualizados.
Tabela 5.6 – Conjunto com as classes originais, saídas de u1 e novos valores de vk (k = 1,..., 8)
Exemplos Ek (k = 1,..., 8) k 1 O (k = 1,..., 8) Classe Ck (k = 1,..., 8) vk (k = 1,..., 8) E1 –1 1 12,3 E2 –1 –1 –10,4 E3 –1 –1 30,4 E4 –1 1 7,7 E5 –1 –1 –7,7 E6 –1 1 0,5 E7 1 1 10,4 E8 –1 –1 –12,3
Como a rede ainda comete um erro de negativo, em E3, o algoritmo insere um neurônio para corrigir este erro. O conjunto usado para treinar um neurônio, para que este corrija erros de negativo, deve ser formado pelas instâncias que na rede atual geram vk > 0, para 1 ≤ k ≤ 8, com as suas classes invertidas. Assim, como pode ser verificado na Tabela 5.6, o conjunto de treinamento do neurônio u2 será formado pelas instâncias: E1, E3, E4, E6 e E7
Capítulo 5 - O Algoritmo Offset
77 Suponha que o neurônio u2, treinado com o conjunto de treinamento {E1, E3, E4, E6,
E7}, tenha obtido o vetor de pesos W2 = 〈1,1 –0,86 1〉 e bias θ2 = –2,1. Essa configuração
permite que u2 fique ativo somente para a instância de treinamento E3 dentre todas do
conjunto original, dessa forma ∆2 = –30,9. A rede, mostrada na Figura 5.3 não comete
nenhum erro.
Figura 5.3 – Rede Shift que representa o conceito de Paridade-3, na qual as TLUs foram treinadas com o BCPMin
5.3 O Algoritmo Offset
Proposto por [Martinez & Estève, 1992] para problemas com atributos booleanos, o Offset é um algoritmo neural construtivo que cria uma rede com duas camadas intermediárias. O processo de construção da rede é dividido em duas fases. Na primeira fase o algoritmo constrói uma rede com duas camadas intermediárias. Na segunda fase, a rede construída é podada, com a eliminação de qualquer neurônio redundante da segunda camada.
A primeira camada intermediária é criada adicionando-se a ela neurônios de acordo com a necessidade da rede, até que o último neurônio não cometa nenhum erro de classificação em seu conjunto de treinamento. Ao fim desse processo essa camada é uma máquina de paridade15 [Mitchison & Durbin 1989] que tem por objetivo transformar qualquer função booleana da entrada em um problema de paridade.
O próximo passo do algoritmo é construir a segunda camada intermediária que tem como objetivo resolver o problema de paridade criado pela primeira camada; a segunda
15
Uma máquina de paridade é uma rede neural que transforma qualquer problema booleano em um problema de paridade. X2 30.9 –30.9 X3 X1 u1 u2
Capítulo 5 - O Algoritmo Offset
78 camada terá, a principio, um número de neurônios igual à dimensão da paridade criada pela primeira camada, ou seja, o número de neurônios na primeira camada.
Após o termino da construção da segunda camada e, conseqüentemente, da primeira fase do algoritmo, a rede Offset classifica corretamente todas as instâncias de treinamento. Como pode acontecer que a segunda camada da rede possua neurônios redundantes, é iniciada a segunda fase do algoritmo, que tem como objetivo reduzir o tamanho da rede com o propósito de aumentar seu poder de generalização [Baum & Haussler 1989], por meio da eliminação de neurônios redundantes na segunda camada.
5.3.1 Fase I - Construção da Primeira Camada de uma Rede Offset
Considere a função f(Ck, Ok) como uma determinada medida de distância entre Ck e Ok para a instância de treinamento Ek, tal que Ok é a saída do neurônio un para a instância Ek de
classe Ck. A idéia é corrigir os erros medidos por f com a introdução de um novo neurônio un+1.
Para que o novo neurônio un+1 possa corrigir os erros do neurônio anterior é necessário
que este fique ativo para os exemplos que foram classificados incorretamente por un e inativo
para os que já estão corretamente classificados. Escolhendo a função booleana ou-exclusivo (xor), como a função de medição de distância, os exemplos que geram erros serão mapeados para 1 e os que estão classificados corretamente em –1. Dessa forma, o procedimento de correção sucessiva na primeira camada pode ser feito como descrito a seguir.
O primeiro neurônio u1 é treinado com o conjunto de exemplos original E. Supondo
que este neurônio cometa alguns erros de classificação, é necessário a adição de um segundo neurônio, u2, para corrigir os erros de u1. O novo neurônio u2 será treinado com E1, que é o
conjunto de treinamento E com suas classes trocadas pelos resultados da função de distância entre a saída do neurônio u1 e suas respectivas classes, para cada toda instância de E.
Se u2 não achar um vetor de pesos que classifique corretamente todos os exemplos de
E1, será criado um novo neurônio u3, e este será treinado com E2 que será formado a partir de
E1 da mesma maneira que no caso anterior, e assim sucessivamente até que a criação e adição de un classifique corretamente todos as instâncias do conjunto de treinamento E(n –1).
É importante ressaltar que o processo de criação da primeira camada de uma rede Offset, previamente citado, somente irá convergir se as instâncias de treinamento possuírem atributos booleanos i.e. 〈x1, x2,..., xp〉 é tal que xi ∈ {0,1}, 1 ≤ i ≤ p ou 〈x1, x2,..., xp〉 é tal que xi
Capítulo 5 - O Algoritmo Offset
79
5.3.2 Fase I - Construção da Segunda Camada de uma Rede Offset
Quando o algoritmo termina a construção da primeira camada, esta camada torna-se uma máquina de paridade que representa o problema booleano original como um problema de paridade-j, sendo j é o número de neurônios que compõem a primeira camada. O problema inicial foi transformado em um problema de paridade de dimensão j.
Para resolver o problema de paridade criado pela primeira camada o algoritmo cria uma segunda camada. Esta camada é formada, a principio, por j neurônios ou seja, o mesmo número de neurônios da camada anterior. Os neurônios da segunda camada, no entanto, não são treinados, e dessa forma, esses neurônios não têm vetor de pesos associado. Ao invés disso, os neurônios da segunda camada fazem uso de thresholds pré-determinados para classificação das paridades. O threshold do i-ésimo neurônio, com 1 ≤ i ≤ j, inserido na segunda camada é obtido segundo a equação (5.5).
i = 2i – j – 1 (5.5)
Cada threshold determinado pela equação (5.5) separa duas paridades, uma que contém as representações com números ímpares de 1s, e a outra, com números pares de 1s. Assim a segunda camada cria j + 1 hiperplanos intercalados entre par e ímpar.
O próximo passo é fazer com que a saída fique inativa para valores pares de i e ativa para valores ímpares. Para isso são adicionados os pesos +1 e –1 de maneira intercalada, começando com +1, e fazendo o threshold do neurônio de saída igual a 0,5. Essa configuração permite que a saída varie de acordo com a paridade de i.
5.3.3 Fase II – A Poda em uma Rede Offset
Como a segunda camada divide o espaço em todos os hiperplanos possíveis, é provável que algum hiperplano nunca seja usado. Portanto os neurônios que geram esses hiperplanos são redundantes na rede, de modo que podem ser podados. Essa etapa é útil para melhorar a generalização da rede, uma vez que a rede criada anteriormente pode não ser mínima devido ao fato da segunda camada ser construída com um número pré-determinado de neurônios.
Para saber se a rede gerada não é mínima considere q o número de representações internas distintas e j o número de neurônios na primeira camada da rede.
Capítulo 5 - O Algoritmo Offset
80 (1) Se q = 2j, o problema de paridade–j está completo. A rede necessita de todos os neurônios da segunda camada para resolvê-lo; neste caso a rede é mínima.
(2) Se q < 2j
, só uma parte do problema de paridade está presente. É possível que algum neurônio da segunda camada seja redundante; neste caso a rede não é mínima.
A implementação da poda pode ser feita de duas maneiras: uma delas é verificar quais dos thresholds não são ativados por nenhuma representação interna. Para isso cada linha da matriz de representações internas é somada e comparada com os thresholds. A outra maneira é utilizar a rede no conjunto original de exemplos e marcar quais dos neurônios da segunda camada nunca são usados.
5.3.4 Considerações sobre o Pseudocódigo do Algoritmo Offset
O Algoritmo 5.2 mostra o pseudocódigo do algoritmo Offset. O primeiro passo do algoritmo é criar um neurônio na primeira camada (representada no pseudocódigo por meio do vetor Camada[]). Esse neurônio é treinado com o conjunto de treinamento original, utilizando algum algoritmo para o treinamento de TLUs para duas classes, representado no pseudocódigo pela classe Neuronio.
Se o primeiro neurônio não consegue classificar corretamente todos os exemplos de treinamento, o método criaTreinamento(), cria um novo conjunto de treinamento, baseado no conjunto de treinamento usado para criar o neurônio anterior. Este método aplica a função de distância xor entre as classes do conjunto usado para treinar o último neurônio e as saídas deste neurônio para criar as classes do novo conjunto de treinamento.
O processo de inserção de neurônios na primeira camada termina quando o último neurônio adicionado conseguir classificar corretamente todo o seu conjunto de treinamento. Quando isso acontece a primeira camada é uma máquina de paridade e o próximo passo é criar a segunda camada para resolver o problema da paridade. A segunda camada é representada no pseudocódigo pelo vetor SegCamada[]; esse vetor guarda os thresholds, que são obtidos com o uso de um contador.
Para verificar se o último neurônio adicionado classifica todas as instâncias de seu conjunto de treinamento corretamente, este neurônio juntamente com seu conjunto de treinamento são passados como parâmetro para o método precisao(). Quando a precisão obtida for igual a 1 o método criaMRI() é chamado para criar a matriz de representação interna da primeira camada. Esse método constrói a matriz de representações internas com as saídas já obtidas dos neurônios da primeira camada e retira as possíveis repetições.
Capítulo 5 - O Algoritmo Offset
81 O último passo do algoritmo é verificar se a poda pode ser realizada na segunda camada; caso seja, o método poda() é chamado. Este método faz a poda por meio da verificação das somas de cada linha da matriz de representações internas. Se existir, no vetor de thresholds, um valor que não seja ultrapassado por nenhum resultado das somas das linhas da matriz de representação interna, então esse valor não é copiado para o novo vetor que representará a segunda camada.