Edit page

Conexionistas

Responsáveis pela origem do deep learning, os conexionistas defendem uma aprendizagem conseguida pela simulação do funcionamento do cérebro humano. Assim, existe uma representação computacional do cérebro, mais concretamente dos neurónios e das ligações entre eles. A aprendizagem dá-se no processo de mudança gradual na força das ligações entre os neurónios.

Um neurónio recebe o estímulo através das suas dendrites, processando os sinais e transmitindo os resultados a outros neurónios através do amónio. Contudo, o sinal só é transmitido se os estímulos recebidos ultrapassarem um determinado valor mínimo.

Neurónio

Perceptron

Cada neurónio é representado como uma função de DD variáveis, com o nome de entradas. O resultado é designado por saída. De modo a emular o funcionamento do neurónio, que dispara ou não dispara, é calculada uma função de ativação aplicada à net, que corresponde a uma soma ponderada das entradas. O objetivo do percetrão é, então, classificar uma entrada como pertencente a uma de duas classes: C1=1C_1 = 1 ou C2=1C_2 = -1.

net=j=0dwjxjz^=sign(net)={1se net 01se net <0\text{net} = \sum_{j = 0}^{d}{w_j \cdot x_j} \\ \hat{z} = \text{sign}(\text{net}) = \begin{cases} -1 & \text{se net } \geq 0\\ 1 & \text{se net } < 0 \end{cases}

Processo de Treino

O processo de treino corresponde, então, ao ajuste gradual dos pesos wiw_i, de modo à saída corresponder à classe do registo representado pelas DD entradas, minimizando uma função de erro. Na verdade, os parâmetros dos pesos correspondem a um hiperplano em DD dimensões. Este hiperplano separa as duas classes dos dados, que são representadas como pontos em DD dimensões, correspondentes aos registos dos dados.

A atualização dos pesos é feita de acordo com a regra seguinte, em que 0<η10 < \eta \leq 1 corresponde à learning rate, que determina o tamanho da variação efetuada aos pesos.

wnew=wold+ΔwΔw=η(zz^)xw^{new} = w^{old} + \Delta w \\ \Delta w = \eta (z - \hat{z}) \cdot x \\

Note-se que (zz^)(z - \hat{z}) representa o erro, δk=zkz^k\delta_k = z_k - \hat{z}_k que pode tomar valores 2, -2 ou 0.

δk={2se zk=1 e z^k=12se zk=1 e z^k=10se zk=z^k\delta_k = \begin{cases} 2 & \text{se } z_k = 1 \text{ e } \hat{z}_k = -1 \\ -2 & \text{se } z_k = -1 \text{ e } \hat{z}_k = 1 \\ 0 & \text{se } z_k = \hat{z}_k \\ \end{cases}

Algoritmo

O algoritmo de treino do percetrão, abaixo descrito, converge para uma classificação correta se o conjunto de treino for linearmente separável e η\eta for suficientemente pequeno. É de notar que um valor demasiado pequeno de η\eta faz com que o algoritmo não tanto em tenha em conta a contribuição de observações seguintes. Por outro lado, uma valor de η\eta demasiado grande pode desvalorizar as observações anteriormente consideradas. É necessário equilibrar estes dois conflitos.

  1. Inicializar os pesos com valores arbitrários.
  2. Escolher um registo xkx_k.
  3. Calcular o valor de net.
  4. Calcular o valor do output = ff(net), em que ff é a função de ativação.
  5. Calcular Δw\Delta w e atualizar os pesos.
  6. Repetir a partir de 2. até não ser realizada nenhuma atualização aos pesos.

Limitações

É de notar que este modelo apenas consegue representar conjuntos que sejam separáveis por uma linha, denominados conjuntos linearmente separáveis. Por exemplo, este é incapaz de aprender a operação de ou exclusivo (XOR), pois não há uma linha no plano que separe as classes correspondentes aos valores lógicos V e F.

Perceptron de Operações Lógicas

Funções de Ativação

Existem várias funções de ativação. As mais relevantes encontram-se listadas a seguir.

  • Sign Function
    f(x)={1se x00se x<0f(x) = \begin{cases} 1 & \text{se } x \geq 0 \\ 0 & \text{se } x < 0 \end{cases}
  • Sigmoid Function
    f(x)=11+eaxf(x) = \frac{1}{1 + e^{-ax}}
  • Hyperbolic Tangent
    f(x)=1e2x1+e2xf(x) = \frac{1 - e^{-2x}}{1 + e^{-2x}}
  • Softmax
    f(xi)=exij=1Nexjf(x_i) = \frac{e^{x_i}}{\sum\limits_{j=1}^{N} e^{x_j}}

Cross-Entropy

A função sigmóide, para o valor de a=1a = 1, converte a sua entrada numa probabilidade, sendo o seu contradomínio [0,1][0, 1]. Assim, podemos converter o valor de net numa probabilidade. Pois na tarefa de classificação apenas existem duas classes, podemos realizar a seguinte interpretação:

P(c1x)=σ(j=0Nwjxj)=σ(wTx) e P(c2x)=1P(c1x)P(c_1 \mid x) = \sigma\left(\sum_{j=0}^{N} w_j \cdot x_j\right) = \sigma(w^T \cdot x) \quad \text{ e } \quad P(c_2 \mid x) = 1 - P(c_1 \mid x)

Assim, os neurónios disparam com uma probabilidade P(c1xi)P(c_1 \mid x_i) e não disparam com uma probabilidade 1P(c1xi)1 - P(c_1 \mid x_i). Logo, o neurónio segue uma distribuição de Bernoulli.

P(ziw,xi)Ber(P(c1xi))P(z_i \mid w, x_i) \sim \text{Ber}(P(c_1 \mid x_i))

Assumindo independência no conjunto de dados, podemos estimar os pesos do modelo tal que o likelihood seja maximizada. Assim, chegamos à expressão da função de erro da cross-entropy.

E[w]=log(P(zw))=i=1N(zilogz^i+(1z)log(1z^i))E[w] = -\log(P(z \mid w)) = -\sum_{i=1}^{N} (z_i \log \hat{z}_i + (1 - z) \log(1 - \hat{z}_i))

Gradient Descent

Este é um método numérico utilizado para determinar o mínimo da funções que não podem ser determinados algebricamente. O algoritmo começa por receber uma função a minimizar, E[w]E[w] e escolhe um vetor de pesos inicial, winitialw^{initial} e, a cada iteração, soma este vetor a outro com sentido E[w]- \nabla E[w].

Assim, cada coordenada do vetor vê-se incrementada de acordo com a seguinte regra.

wjnew=wjold+Δwj onde Δwj=ηEwjw_j^{new} = w_j^{old} + \Delta w_j \quad \text{ onde } \Delta w_j = -\eta \cdot \dfrac{\partial E}{\partial w_j}

O processo continua até que o algoritmo convirja para um solução (η\eta tem de ser pequeno o suficiente), pois o erro definido por E[w]E[w] contém apenas um mínimo global. Para um valor de η\eta muito grande, poderíamos sobrestimar o passo e passar para lá deste mínimo global.

Vertentes de Gradient Descent

Enquanto que o método de gradient descent atualiza os pesos depois de considerar todas as observações do conjunto de treino, calculando o erro acumulado, o método do stochastic gradient descent atualiza os pesos a cada observação do conjunto de treino.

Multi-Layer Perceptron

Motivação

De modo a conseguir que o percetrão consiga modelar a função XOR, podemos adicionar ao percetrão várias camadas, ditas intermédias ou escondidas (pois não conseguimos ver qual a sua saída), de modo a emular comportamentos mais complexos. A composição de percetrões são organizadas em camadas, em que as saídas de uma camada influenciam as entradas da camada seguinte. Daí este modelo ser conhecido como feed forwards network.

Contudo, múltiplas camadas de unidades lineares não deixam de poder apenas representar funções lineares. Para representar funções não lineares, necessitamos de funções de ativação não lineares. Assim, um percetrão multi camada com camadas escondidas consegue aproximar qualquer região contínua com um erro arbitrariamente pequeno. A camada de saída deste modelo pode ser treinada como se tratasse de um percetrão de uma só camada.

O percetrão simples apenas conseguia realizar classificação binária. Com várias camadas é agora possível realizar tarefas de classificação (com mais de duas classes) e regressão.

O objetivo passa por estimar um matrizes de pesos, ww, de modo a minimizar uma função de erro E[w]E[w].

Perceptron Multi Camada

Notação

A primeira e última camada são a camada de entrada e a camada de saída, respetivamente. A camada de entrada recebe o índice 1. As entradas da primeira camada correspondem aos valores x1x_1 a xnx_n, sendo nn o número de entradas. Existe também um termo de bias correspondente a x0=1x_0 = 1. Na camada de saída, temos os valores das kk saídas, z^1\hat{z}_1 até z^k\hat{z}_k.

Entre cada duas camadas adjacentes, existem ligações entre todos as unidades. Os valores destas ligações correspondem aos pesos. Define-se wab[n]w_{ab}^{[n]} como a ligação entre as unidades aa, da camada n1n-1 e bb, cada camada nn. Os pesos da que ligam as unidades da camada n1n-1 à camada nn são representados por uma matriz, w[n]w^{[n]}, com dimensões b×ab \times a onde aa corresponde ao número de unidades da camada n1n-1 e bb corresponde ao número de unidades da camada nn.

De maneira semelhante, define-se ak[n]a_{k}^{[n]} como o k-ésimo elemento do vetor de output, a[n]a^{[n]}, da camada nn.

Os valores de bias são representados separadamente, por razões práticas, em vetores b[n]b^{[n]}, onde nn corresponde ao número da camada.

Notação Multi Camada

Forward Propagation

Este corresponde ao processo de, dada uma entrada, calcular a saída da última camada. Dada uma observação xx, a primeira camada escondida recebe uma entrada dada por

net[1]=w[1]x+b[1]net^{[1]} = w^{[1]} \cdot x + b^{[1]}

e calcula uma saída dada por

a[1]=f(net[1])a^{[1]} = f(net^{[1]})

onde ff representa a função de ativação escolhida.

De uma forma geral, este processo pode ser escrito na seguinte fórmula geral, em que consideramos os valores de entrada, a observação xx como a saída da camada 0, a[0]a^{[0]}.

net[n]=w[n]a[n1]+b[n]net^{[n]} = w^{[n]} \cdot a^{[n-1]} + b^{[n]}
a[n]=f(net[n])=f(w[n]a[n1]+b[n])a^{[n]} = f(net^{[n]}) = f(w^{[n]} \cdot a^{[n-1]} + b^{[n]})

O output da camada de saída, a[n]a^{[n]}, num percetrão de nn camadas, corresponde à classificação final.

Backward Propagation

Este processo corresponde a, calculada a saída correspondente a uma entrada, calcular o erro da classificação e ajustar as várias matrizes de pesos adequadamente. Para tal, é aplicada um algoritmo de gradient descent, pois E[w]E[w] é diferenciável se a função de ativação ff também o for.

Transformações do Conjunto de Dados

As camadas escondidas deste modelo conseguem realizar transformações lineares ao conjunto de dados. Assim, além de aprender quais os melhores valores para o vetor de pesos, o modelo também aprende qual a melhor transformação a realizar ao conjunto de dados, de modo a minimizar a função de erro. Isto faz com que o MLP seja um modelo com bastante poder expressivo.

Overfitting

De modo a evitar o overfitting do MLP ao conjunto de dados, pode ser implementada uma política de early stoppng, onde o processo de treino é terminado antes que o modelo sofra de overfitting. As observações de treino são então divididas num conjunto de treino e noutro conjunto de validação. O processo de treino é interrompido quando o erro de teste aumenta durante iterações consecutivas.

Outra solução para este problema passa por adicionar um termo de regularização à função de erro.