Colabore! Saiba mais screen_rotation

Ao navegar por este site , você concorda com a Política de Uso de Dados.

| | | | |

3 Perceptron Multicamadas 3 Perceptron Multicamadas 3.2 Aplicação: Problema de Classificação Binária

3.1 Modelo MLP

Ajude a manter o site livre, gratuito e sem propagandas. Colabore!

Uma perceptron multicamadas (MLP, do inglês, multilayer perceptron) é um tipo de rede neural artificial formada por composições de camadas de perceptrons. Consultamos a Figura 3.1.

Figura 3.1: Arquitetura de uma rede do tipo perceptron multicamadas (MLP).

Denotamos uma MLP de $n_{l}$ camadas por

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\boldsymbol{y}% =\mathcal{N}\left(\boldsymbol{x};\left(W^{(l)},\boldsymbol{b}^{(l)},f^{(l)}% \right)_{l=1}^{n_{h}+1}\right),

(3.1)

onde $\left(W^{(l)},\boldsymbol{b}^{(l)},f^{(l)}\right)$ é a tripa de pesos, biases e função de ativação da $l$ -ésima camada da rede, $l=1,2,\dotsc,n_{h}+1$ . Uma rede com essa arquitetura é dita ter uma camada de entrada, $n_{h}$ camadas escondidas e uma camada de saída.

A saída da rede é calculada por iteradas composições das camadas, i.e.

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\boldsymbol{a}% ^{(l)}=f^{(l)}\underbrace{\left(W^{(l)}\boldsymbol{a}^{(l-1)}+\boldsymbol{b}^{% (l)}\right)}_{\boldsymbol{z}^{(l)}},

(3.2)

para $l=1,2,\dotsc,n_{h}+1$ , denotando a entrada por $\boldsymbol{x}=:\boldsymbol{a}^{(0)}$ e a saída por $\boldsymbol{y}=:\boldsymbol{a}^{(n_{h}+1)}$ .

3.1.1 Treinamento

Em um treinamento supervisionado, tem-se um dado conjunto de treinamento $\{\boldsymbol{x}^{(s)},\boldsymbol{y}^{(s)}\}_{s=1}^{n_{s}}$ , com $n_{s}$ amostras. O treinamento da rede consiste em resolver o problema de minimização

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\min_{(W,% \boldsymbol{b})}\left\{\varepsilon:=\frac{1}{n_{s}}\sum_{s=1}^{n_{s}}% \varepsilon^{(s)}\left(\tilde{\boldsymbol{y}}^{(s)},\boldsymbol{y}^{(s)}\right% )\right\}

(3.3)

onde $\varepsilon$ é uma dada função erro (em inglês, loss function) e $\varepsilon^{(s)}$ é uma medida do erro da saída estimada $\tilde{\boldsymbol{y}}^{(s)}$ da saída esperada $\boldsymbol{y}^{(s)}$ .

O problema de minimização pode ser resolvido por um método de declive e, de forma geral, consiste em:

1.

$W,\boldsymbol{b}$ aproximações iniciais.
2.
Para $e\leftarrow 1,\dotsc,n_{e}$ :
1. (a)
  
  $\displaystyle(W,\boldsymbol{b})\leftarrow(W,\boldsymbol{b})-l_{r}\boldsymbol{d% }\left(\nabla_{W,\boldsymbol{b}}\varepsilon\right)$

onde, $n_{e}$ é o número de épocas, $l_{r}$ é uma dada taxa de aprendizagem (em inglês, learning rate)) e $\boldsymbol{d}=\boldsymbol{d}\left(\nabla_{W,\boldsymbol{b}}\varepsilon\right)$ é o vetor direção, onde

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\nabla_{W,% \boldsymbol{b}}\varepsilon$	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}:=\left(\frac{% \partial\varepsilon}{\partial W},\frac{\partial\varepsilon}{\partial% \boldsymbol{b}}\right)$		(3.4)
		$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}=\frac{1}{ns}% \sum_{s=1}^{n_{s}}\left(\frac{\partial\varepsilon^{(s)}}{\partial W},\frac{% \partial\varepsilon^{(s)}}{\partial\boldsymbol{b}}\right)$		(3.5)

O cálculo dos gradientes pode ser feito por retropropagação (em inglês, backward). Para os pesos da última camada, temos⁷⁷endnote: ⁷Com um cero abuso de linguagem devido à álgebra matricial envolvida.

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\frac{\partial% \varepsilon^{(s)}}{\partial W^{(n_{h}+1)}}$	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}=\frac{% \partial\varepsilon^{(s)}}{\partial\boldsymbol{y}}\frac{\partial\boldsymbol{y}% }{\partial\boldsymbol{z}^{(n_{h}+1)}}\frac{\partial\boldsymbol{z}^{(n_{h}+1)}}% {\partial W^{(n_{h}+1)}}$		(3.6)
		$\displaystyle=\frac{\partial\varepsilon^{(s)}}{\partial\boldsymbol{y}}f^{% \prime}\left(W^{(n_{h}+1)}\boldsymbol{a}^{(n_{h})}+\boldsymbol{b}^{(n_{h}+1)}% \right)\boldsymbol{a}^{(n_{h})}.$		(3.7)

Para os pesos da penúltima camada, temos

$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\frac{\partial% \varepsilon^{(s)}}{\partial W^{(n_{h})}}$	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}=\frac{% \partial\varepsilon}{\partial\boldsymbol{y}}\frac{\partial\boldsymbol{y}}{% \partial\boldsymbol{z}^{(n_{h}+1)}}\frac{\partial\boldsymbol{z}^{(n_{h}+1)}}{% \partial W^{(n_{h})}},$	(3.8)
	$\displaystyle=\frac{\partial\varepsilon^{(s)}}{\partial\boldsymbol{y}}f^{% \prime}\left(\boldsymbol{z}^{(n_{h}+1)}\right)\frac{\partial\boldsymbol{z}^{(n% _{h}+1)}}{\partial\boldsymbol{a}^{(n_{h})}}\frac{\partial\boldsymbol{a}^{(n_{h% })}}{\partial\boldsymbol{z}^{(n_{h})}}\frac{\partial\boldsymbol{z}^{(n_{h})}}{% \partial W^{(n_{h})}}$	(3.9)
	$\displaystyle=\frac{\partial\varepsilon^{(s)}}{\partial\boldsymbol{y}}f^{% \prime}\left(\boldsymbol{z}^{(n_{h}+1)}\right)W^{(n_{h}+1)}f^{\prime}\left(% \boldsymbol{z}^{(n_{h})}\right)\boldsymbol{a}^{(n_{h}-1)}$	(3.10)

e assim, sucessivamente para as demais camadas da rede. Os gradientes em relação aos biases podem ser calculados de forma análoga.

3.1.2 Aplicação: Problema de Classificação XOR

Vamos desenvolver uma MLP que faça a operação xor (ou exclusivo). A rede recebe como entrada dois valores lógicos $A_{1}$ e $A_{2}$ (V, verdadeiro ou F, falso) e fornece como saída o valor lógico $R=A_{1}\texttt{xor}A_{2}$ . Consultamos a tabela verdade:

$A_{1}$	$A_{2}$	$R$
V	V	F
V	F	V
F	V	V
F	F	F

Assumindo $V=1$ e $F=-1$ , podemos modelar o problema tendo entradas $\boldsymbol{x}=(x_{1},x_{2})$ e saída $y$ como na seguinte tabela:

$x_{1}$	$x_{2}$	$y$
$1$	$1$	$-1$
$1$	$-1$	$1$
$-1$	$1$	$1$
$-1$	$-1$	$-1$

Modelo

Vamos usar uma MLP de estrutura $2-2-1$ e com funções de ativação $f^{(1)}(\boldsymbol{x})=\tanh(\boldsymbol{x})$ e $f^{(2)}(\boldsymbol{x})=id(\boldsymbol{x})$ . Ou seja, nossa rede tem duas entradas, uma camada escondida com 2 unidades (função de ativação tangente hiperbólica) e uma camada de saída com uma unidade (função de ativação identidade).

Treinamento

Para o treinamento, vamos usar a função erro quadrático médio (em inglês, mean squared error)

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\varepsilon:=% \frac{1}{n_{s}}\sum_{s=1}^{n_{s}}\left|\tilde{y}^{(s)}-y^{(s)}\right|^{2},

(3.11)

onde $\tilde{y}^{(s)}=\mathcal{N}\left(\boldsymbol{x}^{(s)}\right)$ são os valores estimados e $\left\{\boldsymbol{x}^{(s)},y^{(s)}\right\}_{s=1}^{n_{s}}$ , $n_{s}=4$ , o conjunto de treinamento conforme na tabela acima.

Implementação

O seguinte código implementa a MLP com Método do Gradiente Descendente (DG) como otimizador do algoritmo de treinamento.

Código 6: mlp_xor.py

⬇

1import torch

3# modelo

5model = torch.nn.Sequential()

6model.add_module('layer_1', torch.nn.Linear(2,2))

7model.add_module('fun_1', torch.nn.Tanh())

8model.add_module('layer_2', torch.nn.Linear(2,1))

11# treinamento

13## optimizador

14optim = torch.optim.SGD(model.parameters(),

15 lr=5e-1)

17## dados de treinamento

18X_train = torch.tensor([[1., 1.],

19 [1., -1.],

20 [-1., 1.],

21 [-1., -1.]])

22y_train = torch.tensor([-1., 1., 1., -1.]).reshape(-1,1)

24print("\nDados de treinamento")

25print("X_train =")

26print(X_train)

27print("y_train = ")

28print(y_train)

30## num max épocas

31nepochs = 5000

32tol = 1e-3

34for epoch in range(nepochs):

36 # forward

37 y_est = model(X_train)

39 # função erro

40 loss = torch.mean((y_est - y_train)**2)

42 print(f'{epoch}: {loss.item():.4e}')

44 # critério de parada

45 if (loss.item() < tol):

46 break

48 # backward

49 optim.zero_grad()

50 loss.backward()

51 optim.step()

54# verificação

55y = model(X_train)

56print(f'y_est = {y}')

3.1.3 Exercícios

E. 3.1.1.

Faça uma nova versão do Código , de forma que a MLP tenha tangente hiperbólica como função de ativação na sua saída.

E. 3.1.2.

Faça uma nova versão do Código usando o método do gradiente estocástico (SGD) como otimizador no algoritmo de treinamento.

E. 3.1.3.

Crie uma MLP para emular a operação lógica $\land$ (e-lógico). No treinamento, use como otimizador:

a)

Método GD.
b)

Método SGD.

E. 3.1.4.

Crie uma MLP para emular a operação lógica $\lor$ (ou-lógico). No treinamento, use como otimizador:

a)

Método GD.
b)

Método SGD.

E. 3.1.5.

Considere uma MLP com $n_{l}=3$ camadas escondidas. Sendo $\varepsilon$ uma dada função erro, calcule:

1.

$\displaystyle\frac{\partial\varepsilon}{\partial W^{n_{l}-2}}$ .
2.

$\displaystyle\frac{\partial\varepsilon}{\partial\boldsymbol{b}^{n_{l}-2}}$ .

Envie seu comentário

As informações preenchidas são enviadas por e-mail para o desenvolvedor do site e tratadas de forma privada. Consulte a Política de Uso de Dados para mais informações. Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

| | | |