Primeira vez aqui? Seja bem vindo e cheque o FAQ!
x

Como utilizar a Rede Neural conhecida como Perceptron para classificar os problemas "AND" e "OR"? Por que o problema "XOR" não pode ser classificado usando o Perceptron? Qual é a solução do problema "XOR"utilizando Redes de Função de Base Radial?

0 votos
65 visitas
perguntada Jul 9 em Ciência da Computação por Carlos Eduardo Véras (11 pontos)  
editado Jul 9 por Carlos Eduardo Véras

Problema 4(*) da aula 26 - Aprendizagem de Máquinas - Modelos Lineares para classificação.

Compartilhe

1 Resposta

0 votos
respondida Jul 9 por Carlos Eduardo Véras (11 pontos)  
editado Jul 10 por Carlos Eduardo Véras

Os códigos completos podem ser acessados aqui.

Perceptron para classificar os problemas "AND" e "OR"

O perceptron é a forma mais simples de rede neural utilizada para a classificação de um tipo especial de padrão chamado de "linearmente separável" (Haykin, 2001). A rede consiste em um único neurônio com os pesos e viés sinápticos ajustáveis, conforme figura abaixo. A entradas são representadas por xi, os pesos por wi, o viés por b (bias) e a saída da rede por y; a é a função de ativação.

A imagem será apresentada aqui.
Figura 1 - O perceptron de única camada.

Com o perceptron, grosso modo, o problema de classificação resume-se ao fornecimento das entradas e das saídas esperadas, ao passo que a rede deve ter seus pesos e viés ajustados de modo que a função de ativação forneça a saída esperada.

Os problemas "AND" e "OR" podem ser representados por meio da figura a seguir, na qual se tem as entradas e saídas esperadas. Importante notar que o problema de classificação consiste em duas entradas e uma classe de saída.
A imagem será apresentada aqui.
Figura 2 - Representação dos problemas "AND" e "OR".

Agora podemos passar para a proposta mais simples de solução dos problemas por meio de uma implementação em Python.


Perceptron escrito em Python para classificar os problemas "AND" e "OR"

Na primeira proposta de implementação, tem-se a função de previsão (predict), a qual recebe as entradas, os pesos e o viés definidos a priori (para aprendizado dos pesos pode ser implementado o gradiente descendente ou alguma de suas variações) . Então é realizada a combinação linear por meio da soma das entradas multiplicadas pelo peso. O passo seguinte é inserir esse valor dentro da função de Heaviside (Figura 3) junto com o viés, que nos retornará o output (0 ou 1).

A imagem será apresentada aqui.
Figura 3 - Função de Heaviside.

O código em Python, portanto, é o seguinte:

 # Realiza a previsão com os pesos, viés e dados de entrada
 def predict(row, weights):
 activation = weights[0]
 for i in range(len(row)-1):
     activation += weights[i + 1] * row[i]
 return 1.0 if activation >= 0.0 else 0.0 # função de ativação de Heaviside

if __name__ == '__main__':    

  print("Previsão da função AND\n")    
  # Classificação do "AND"
  # dados de entrada [X1, X2, Y]
  dataset = [[1,1,1],
           [1,0,0],
           [0,1,0], 
           [0,0,0]]

   # viés, peso1, peso2
   weights = [-0.5, 0.25, 0.25]

   for row in dataset:
       prediction = predict(row, weights)
       print("Esperado=%d, Previsto=%d" % (row[-1], prediction))

   print("\n")
   print("Previsão da função OR\n")    
   # Classificação do "OR"
   # dados de entrada [X1, X2, Y]
   dataset = [[1,1,1],
             [1,0,1],
             [0,1,1], 
             [0,0,0]]

   # viés, peso1, peso2
   weights = [-0.25, 0.25, 0.25]

   for row in dataset:
       prediction = predict(row, weights)
       print("Esperado=%d, Previsto=%d" % (row[-1], prediction))

Executando o código acima o resultado será:


 Previsão da função AND

Esperado=1.000000, Previsto=1.000000
Esperado=0.000000, Previsto=0.000000
Esperado=0.000000, Previsto=0.000000
Esperado=0.000000, Previsto=0.000000


Previsão da função OR

Esperado=1.000000, Previsto=1.000000
Esperado=1.000000, Previsto=1.000000
Esperado=1.000000, Previsto=1.000000
Esperado=0.000000, Previsto=0.000000

O perceptron e o problema "XOR"

O perceptron de camada única conforme indicado anteriormente, é capaz de solucionar problemas linearmente separáveis como o das funções booleanas "AND" e o "OR". Ou seja, é possível encontrar retas que separam os vetores de entrada em regiões tal que a saída reflete corretamente o resultados desses funções (Figura 2).

Por outro lado, a função booleana "XOR"(Figura 4), não é linearmente separável, demandando, portanto, duas retas discriminatórias para realizar a separação.

A imagem será apresentada aqui.
Figura 4 - Representação do problema "XOR".

Resolvendo o problema "XOR" por meio das Redes de Função de Base Radial

Segundo Haykin (2001, pgs. 283), a solução do problema de uma rede neural supervisionada pode ser resolvido tanto por meio do algoritmo de retropropagação utilizado para um perceptron de múltiplas camadas (abordagem estocástica), como por uma técnica de ajuste de curva (aproximação) em um espaço de multidimensionalidade. De acordo esta abordagem de aproximação, aprender é equivalente a encontrar uma superfície, em um espaço multidimensional, que forneça o melhor ajuste para os dados de treinamento. Tal abordagem é a motivação por trás do método das funções de base radial, pois no contexto de uma rede neural, as unidades ocultas fornecem um conjunto de funções que constituem uma base arbitrária para os vetores de entrada, quando eles são expandidos sobre o espaço oculto: estas funções são chamadas de funções de base radial.

A construção de uma rede de função de base radial (RBF, radial-basis function) - Figura 5 - envolve três camadas com papéis distintos (Haykin, 2001). A camada de entrada é constituída por nós de fonte (unidades sensoriais) que conectam a rede ao seu ambiente. A segunda camada, a única camada oculta da rede, aplica uma transformação não linear no espaço de entrada para o espaço oculto. A camada de saída é linear, fornecendo a resposta da rede ao padrão (sinal) de ativação aplicado à camada de entrada.
A imagem será apresentada aqui.
Figura 5 - Arquitetura de uma Rede de Função de Base Radial

Para o problema XOR, a RBF consiste de um par de funções gaussianas definidas como:

A imagem será apresentada aqui.

onde os centros t1 e t2 são:

A imagem será apresentada aqui.

A unidade de saída utiliza compartilhamento de pesos uma vez que o problema é simétrico. Ademais, a unidade de saída inclui um viés (bias, b), pois os valores de saída desejados da função XOR têm média diferente de zero.

A saída da RBF pode então ser representada por:

A imagem será apresentada aqui.

O ajuste dos dados de treinamento será feito da seguinte forma:
A imagem será apresentada aqui.

Abaixo segue o código Python que implementa a solução do problema XOR por meio da abordagem de RBF.


 import numpy as np

 # calcula a norma para a função Gaussiana
 def norm(x):

     return np.sqrt(x[0]**2 + x[1]**2)

# calcula a função gaussiana para cada elemento da matriz
def gaussian(x, t):

      return np.exp(-(norm(x - t))**2)


if __name__ == '__main__':    

# entradas da função booleana XOR
x = np.array(((1.,1.),
              (0.,1.),
              (0.,0.),
              (1.,0.)))

print (" ### Entrada da Função XOR ###")
print (x) 
print("\n")


# saídas - alvos - da  função booleana XOR
d = np.array((0.,1.,0.,1.))

# Matriz G de funções de Gaussianas com viés (b = 1.0)
G = np.ones((x.shape[0],x.shape[1]+1))

# centros das funções Gaussianas
t = np.array(((1.,1.),
              (0.,0.)))

cols = x.shape[1]
lins = x.shape[0]

for i in range (lins):
    for j in range(cols):
        G[i][j] = gaussian(x[i], t[j])

print (" ### Matriz de Funções Gaussianas ###")
print (G) 
print("\n")

# calcula os pesos por meio da solução de norma mínima
# w = G_plus*d = (G.T*G)^-1*G.T*d 
G_plus = np.linalg.inv(np.dot(G.T, G))
G_plus = np.dot(G_plus, G.T)
w = np.dot(G_plus, d)

print (" ### Vetor de Pesos ###")
print (w)
print("\n")

# calcula as saídas da rede neural       
y = np.dot(G, w)

# imprime resultados
print(" ### RESULTADOS ### ")

i = 0
for row in y:

    print("Esperado=%f, Previsto=%f" % (d[i], row))
    i+=1

A saída esperada do código acima é a seguinte:


### Entrada da Função XOR ###
[[ 1.  1.]
 [ 0.  1.]
 [ 0.  0.]
 [ 1.  0.]]


### Matriz de Funções Gaussianas ###
[[ 1.                     0.13533528   1.        ]
[ 0.36787944  0.36787944   1.        ]
[ 0.13533528  1.                       1.        ]
[ 0.36787944  0.36787944    1.        ]]


### Vetor de Pesos ###
[-2.5026503  -2.5026503   2.84134719]


### RESULTADOS ### 
 Esperado=0.000000, Previsto=0.000000
 Esperado=1.000000, Previsto=1.000000
 Esperado=0.000000, Previsto=0.000000
 Esperado=1.000000, Previsto=1.000000

...