Deep Learning para Equações Diferenciais Parciais

2 Perceptron 2 Perceptron 2.2 Treinamento por retro-propagação

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

2.1 Unidade de processamento

A unidade básica de processamento (neurônio artificial) do tipo perceptron segue o esquema dado na Figura 2.1. Consiste na composição de uma função de ativação¹¹1Originalmente, o perceptron tem a função sinal como função de ativação. Por referência histórica, vamos adotar este nome mesmo para unidades de processamento com outras funções de ativação $\varphi:\mathbb{R}\to\mathbb{R}$ com a pré-ativação

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% z:=\boldsymbol{w}\cdot\boldsymbol{x}+b$		(2.1)
	$\displaystyle\text{}\quad=w_{0}x_{0}+w_{1}x_{1}+\cdots+w_{n-1}x_{n-1}+b$		(2.2)

onde, $\boldsymbol{x}=(x_{0},x_{1},\dotsc,x_{n-1})\in\mathbb{R}^{n}$ é o vetor de entrada, $\boldsymbol{\theta}=(\boldsymbol{w},b)\in\mathbb{R}^{n+1}$ são of parâmetros da unidade, formados pelos pesos $\boldsymbol{w}=(w_{0},w_{1},\dotsc,w_{n-1})\in\mathbb{R}^{n}$ e o bias $b\in\mathbb{R}$ . Escolhida uma função de ativação, a saída do neurônio é computada por

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% y=\mathcal{N}\left(\boldsymbol{x};\boldsymbol{\theta}\right)$		(2.3)
	$\displaystyle\text{}\quad:=\varphi(z)=\varphi(\boldsymbol{w}\cdot\boldsymbol{x% }+b)$		(2.4)

Figura 2.1: Esquema de um perceptron (unidade básica de processamento).

O treinamento (calibração) consiste em determinar os parâmetros $\boldsymbol{\theta}$ de forma que o neurônio forneça as saídas $y$ esperadas com base em um critério predeterminado. O perceptron é um classificador linear, i.e. é capaz de classificar dados que sejam linearmente separáveis.

2.1.1 Um problema de classificação

Vamos desenvolver um perceptron que emule a operação booleana²²2George Boole, 1815 - 1864, matemático britânico. Fonte: Wikipédia: George Boole. $\land$ (e-lógico). Mais especificamente, dados dois valores booleanos $A_{1}$ e $A_{2}$ (V, verdadeiro ou F, falso), esperamos que nosso neurônio forneça como saída o valor booleano $R=A_{1}\land A_{2}$ . Lembremos a tabela verdade da operação $\land$ :

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

Modelo

Nosso modelo será um perceptron com duas entradas $\boldsymbol{x}\in\{-1,1\}^{2}$ e a função sinal

	$\displaystyle\varphi(z)=\operatorname{sign}(z)$		(2.5)
	$\displaystyle\text{}\quad:=\begin{cases}1&,z>0\\ 0&,z=0\\ -1&,z<0\end{cases}$		(2.6)

como função de ativação. Com isso, nosso modelo fornece a seguinte saída

	$\displaystyle y=\mathcal{N}\left(\boldsymbol{x};\boldsymbol{\theta}\right),$		(2.7)
	$\displaystyle\text{}\quad=\operatorname{sign}(\boldsymbol{w}\cdot\boldsymbol{x% }+b),$		(2.8)

onde $\boldsymbol{\theta}=(w_{0},w_{1},b)\in\mathbb{R}^{3}$ são parâmetros a determinar. A ideia, aqui, é que o valor $-1$ esteja associado ao valor lógico $F$ (falso) e o valor $1$ ao valor lógico $V$ (verdadeiro).

Pré-processamento

Precisamos pré-processar os dados do problema de forma a compatibilizá-los com o modelo. Assumindo que valor booleano $F$ (falso) seja associado a $-1$ e que valor booleano $V$ (verdadeiro) a $1$ , temos os seguintes dados de treinamento para o nosso modelo de neurônio

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

Treinamento

Agora, nos falta treinar nosso neurônio para fornecer o valor de $y$ esperado para cada dada entrada $\boldsymbol{x}$ . Isso consiste em um método para escolhermos os parâmetros $\boldsymbol{\theta}$ que sejam adequados para esta tarefa. Vamos explorar mais sobre isso na sequência do texto, mas, aqui, vamos empregar uma análise geométrica para escolhermos os parâmetros $\boldsymbol{\theta}$ .

Lembrando que nosso modelo é dado por

\mathcal{N}\left(\boldsymbol{x};(\boldsymbol{w},b)\right)=\operatorname{sign}(% w_{0}x_{0}+w_{1}x_{1}+b),

(2.9)

observamos que

w_{0}x_{0}+w_{1}x_{1}+b=0

(2.10)

corresponde à equação geral de uma reta no plano $\tau:x_{0}\times x_{1}$ . Esta reta divide o plano em dois semiplanos

	$\displaystyle\tau^{+}=\{\boldsymbol{x}\in\mathbb{R}^{2}:w_{0}x_{0}+w_{1}x_{1}+% b>0\}$		(2.11)
	$\displaystyle\tau^{-}=\{\boldsymbol{x}\in\mathbb{R}^{2}:w_{0}x_{0}+w_{1}x_{1}+% b<0\}$		(2.12)

O primeiro está na direção do vetor normal à reta $\boldsymbol{w}=(w_{0},w_{1})$ e o segundo no sentido oposto. Com isso, o problema de treinar nosso neurônio para o problema de classificação consiste em encontrar a reta

w_{0}x_{0}+w_{1}x_{1}+b=0

(2.13)

de forma que o ponto $(1,1)$ esteja no semiplano positivo $\tau^{+}$ e os demais pontos no semiplano negativo $\tau^{-}$ . Consultemos a Figura 2.2.

Refer to caption — Figura 2.2: Interpretação geométrica do perceptron aplicado ao problema de classificação associado à operação lógica $\land$ (e-lógico).

Com base nessa interpretação geométrica, podemos escolher os parâmetros $\boldsymbol{\theta}=(\boldsymbol{w},b)$ do nosso modelo de neurônio. Por exemplo, podemos escolher

	$\displaystyle\boldsymbol{w}=(1,1),$		(2.14)
	$\displaystyle b=-1.$		(2.15)

Com isso, nosso perceptron é

\mathcal{N}(\boldsymbol{x})=\operatorname{sign}(x_{0}+x_{1}-1)

(2.16)

Verifique que o modelo fornece a saída esperada para cada dada entrada $\boldsymbol{x}$ .

Implementação

O Código 1 é uma implementação deste modelo de neurônio. Verifique!

Código 1: perceptron.py

⬇

1import torch

3# modelo

4class Perceptron(torch.nn.Module):

5 def __init__(self):

6 super().__init__()

7 self.linear = torch.nn.Linear(2,1)

9 def forward(self, x):

10 z = self.linear(x)

11 y = torch.sign(z)

12 return y

14model = Perceptron()

16# escolha dos parâmetros

17W = torch.Tensor([[1., 1.]])

18b = torch.Tensor([-1.])

19with torch.no_grad():

20 model.linear.weight = torch.nn.Parameter(W)

21 model.linear.bias = torch.nn.Parameter(b)

23# dados de entrada

24X = torch.tensor([[1., 1.],

25 [1., -1.],

26 [-1., 1.],

27 [-1., -1.]])

29print(f"\nDados de entrada\n{X}")

32# aplicação

33y = model(X)

35print(f"Valores estimados\n{y}")

2.1.2 Algoritmo de treinamento: perceptron

O algoritmo de treinamento perceptron permite computar os parâmetros de um neurônio para fazer a classificação de dados linearmente separáveis. Trata-se de um algoritmo para o treinamento supervisionado de um modelo, i.e.. a calibração dos pesos é feita com base em um dado conjunto de amostras de treinamento.

Seja dado um conjunto de treinamento $\{\boldsymbol{x}^{(s)},y^{(s)}\}_{s=0}^{n_{s}-1}$ , onde $n_{s}$ é o número de amostras. O algoritmo consiste no seguinte:

1.

$\boldsymbol{w}\leftarrow\boldsymbol{0}$ , $b\leftarrow 0$ .
2.
Para $e\leftarrow 1,\dotsc,n_{e}$ :
1. (a)
  Para $s\leftarrow 1,\dotsc,n_{s}$ :
  1. i.
    
    Se $y^{(s)}\mathcal{N}\left(\boldsymbol{x}^{(s)}\right)\leq 0$ :
    
    A.
    
    $\boldsymbol{w}\leftarrow\boldsymbol{w}+y^{(s)}\boldsymbol{x}^{(s)}$
    
    B.
    
    $b\leftarrow b+y^{(s)}$

onde, $n_{e}$ é um dado número de épocas. Usualmente, uma época consiste no número de vezes que todas as amostras serão utilizadas para realizar a correção dos pesos.

Para mostrarmos a convergência do algoritmo de treinamento perceptron, vamos simplificar a notação, assumindo $\boldsymbol{\tilde{x}}=(x_{0},x_{1},\dotsc,x_{n-1},1)$ . Com isso, um conjunto $D=\{\boldsymbol{\tilde{x}}^{(s)},y^{(s)}\}_{s=0}^{n_{s}-1}$ é linearmente separável, se existe $\boldsymbol{\theta}$ tal que

y^{(s)}\boldsymbol{\theta}\cdot\tilde{\boldsymbol{x}}^{(s)}>0,

(2.17)

para todas as amostras $s=0,1,\dotsc,n_{s}-1$ . Com isso, temos o seguinte resultado.

Teorema 2.1.1.(Perceptron)

Seja dado um conjunto de treinamento $D=\{\boldsymbol{\tilde{x}}^{(s)},y^{(s)}\}_{s=0}^{n_{s}-1}$ , onde $n_{s}$ é o número de amostras. Se existe $\boldsymbol{\theta}^{*}$ tal que

y^{(s)}\frac{\boldsymbol{\theta}^{*}\cdot\tilde{\boldsymbol{x}}^{(s)}}{\|% \boldsymbol{\theta}\|}\geq\gamma>0,

(2.18)

e $\|\boldsymbol{\tilde{x}}^{s}\|\leq R$ , para $s=0,1,\dotsc,n_{s}-1$ , então o algoritmo de treinamento perceptron converge em no máximo $(R/\gamma)^{2}$ épocas.

Demonstração.

Assuma que iniciamos com $\boldsymbol{\theta}^{(0)}=\boldsymbol{0}$ e que na $k$ -ésima iteração de correção vamos computar os parâmetros $\boldsymbol{\theta}^{(k)}$ . Seja $\beta$ o ângulo entre os vetores $\boldsymbol{\theta}^{(k)}$ e $\boldsymbol{\theta}^{*}$ , então

	$\displaystyle\cos(\beta)=\frac{\boldsymbol{\theta}^{(k)}\cdot\boldsymbol{% \theta}^{}}{\\|\boldsymbol{\theta}^{(k)}\\|\\|\boldsymbol{\theta}^{}\\|}$		(2.19)
	$\displaystyle\text{}\quad=\frac{\boldsymbol{\theta}^{(k)}\cdot\boldsymbol{% \theta}^{}}{\\|\boldsymbol{\theta}^{}\\|}\frac{1}{\\|\boldsymbol{\theta}^{(k)}% \\|}.$		(2.20)

Sem perda de generalidade, suponhamos que a amostra $s$ seja a amostra que gera a correção na $k$ -ésima iteração, ou seja, $y^{(s)}\boldsymbol{\theta}^{(k-1)}\cdot\tilde{\boldsymbol{x}}^{(s)}\leq 0$ . Com isso, temos

	$\displaystyle\frac{\boldsymbol{\theta}^{(k)}\cdot\boldsymbol{\theta}^{}}{\\|% \boldsymbol{\theta}^{}\\|}=\frac{(\boldsymbol{\theta}^{(k-1)}+y^{(s)}\tilde{% \boldsymbol{x}}^{(s)})\cdot\boldsymbol{\theta}^{}}{\\|\boldsymbol{\theta}^{}\\|}$		(2.21)
	$\displaystyle\text{}\quad=\frac{\boldsymbol{\theta}^{(k-1)}\cdot\boldsymbol{% \theta}^{}}{\\|\boldsymbol{\theta}^{}\\|}+y^{(s)}\frac{\tilde{\boldsymbol{x}}^% {(s)}\cdot\boldsymbol{\theta}^{}}{\\|\boldsymbol{\theta}^{}\\|}$		(2.22)
	$\displaystyle\text{}\quad\geq\frac{\boldsymbol{\theta}^{(k-1)}\cdot\boldsymbol% {\theta}^{}}{\\|\boldsymbol{\theta}^{}\\|}+\gamma$		(2.23)
	$\displaystyle\text{}\quad\geq k\gamma,$		(2.24)

por indução matemática. Por outro lado, temos

	$\displaystyle\\|\boldsymbol{\theta}^{(k)}\\|^{2}=\\|\boldsymbol{\theta}^{(k-1)}+y% ^{(s)}\tilde{\boldsymbol{x}}^{(s)}\\|^{2}$		(2.25)
	$\displaystyle\text{}\quad=\\|\boldsymbol{\theta}^{(k-1)}\\|^{2}+\underbrace{2y^{% (s)}\boldsymbol{\theta}^{(k-1)}\cdot\tilde{\boldsymbol{x}}^{(s)}}_{\leq 0}+\\|% \tilde{\boldsymbol{x}}^{(s)}\\|^{2}$		(2.26)
	$\displaystyle\text{}\quad\leq\\|\boldsymbol{\theta}^{(k-1)}\\|^{2}+R^{2}$		(2.27)
	$\displaystyle\text{}\quad\leq kR^{2},$		(2.28)

novamente por indução matemática. Com isso, temos

\displaystyle 1\geq\cos(\beta)\geq k\gamma\frac{1}{\sqrt{k}R}=\sqrt{k}\frac{% \gamma}{R}

(2.29)

e, portanto, $k\leq(R/\gamma)^{2}$ . ∎

Aplicação

O Código 2 contém uma implementação do algoritmo de treinamento perceptron para o problema de classificação associado à operação lógica $\land$ (e-lógico). Verifique!

Código 2: algo_perceptron.py

⬇

1import torch

3# modelo

5class Perceptron(torch.nn.Module):

6 def __init__(self):

7 super().__init__()

8 self.linear = torch.nn.Linear(2,1)

10 def forward(self, x):

11 z = self.linear(x)

12 y = torch.sign(z)

13 return y

15model = Perceptron()

16with torch.no_grad():

17 W = model.linear.weight

18 W.zero_()

19 b = model.linear.bias

20 b.zero_()

22# dados de treinamento

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

24 [1., -1.],

25 [-1., 1.],

26 [-1., -1.]])

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

29## número de amostras

30ns = y_train.size(0)

32print("\nDados de treinamento")

33print("X_train =")

34print(X_train)

35print("y_train = ")

36print(y_train)

38# treinamento

40## num max épocas

41nepochs = 100

43for epoch in range(nepochs):

45 # update

46 not_updated = True

47 for s in range(ns):

48 y_est = model(X_train[s:s+1,:])

49 if (y_est*y_train[s] <= 0.):

50 with torch.no_grad():

51 W += y_train[s]*X_train[s,:]

52 b += y_train[s]

53 not_updated = False

55 if (not_updated):

56 print('Training ended.')

57 break

60# verificação

61print(f'W =\n{W}')

62print(f'b =\n{b}')

63y = model(X_train)

64print(f'y =\n{y}')

2.1.3 Exercícios

E. 2.1.1.

Dado um perceptron com parâmetros $\boldsymbol{w}=(1,-1)$ e $b=0.5$ , esboce a reta de separação associada a este modelo e indique os semiplanos $\tau^{+}$ e $\tau^{-}$ . Então, classifique os seguintes pontos utilizando este modelo: $(1,0)$ , $(0,1)$ , $(-1,1)$ e $(-1,-1)$ .

E. 2.1.2.

Crie um perceptron que emule a operação booleana do $\lor$ (ou-lógico).

$A_{1}$	$A_{2}$	$A_{1}\lor A_{2}$
V	V	V
V	F	V
F	V	V
F	F	F

Primeiramente, treine-o utilizando uma análise geométrica. Depois, implemente o algoritmo de treinamento perceptron para treinar os parâmetros do modelo.

E. 2.1.3.

Crie um perceptron que emule a operação booleana do $\lnot$ (não-lógico).

$A$	$\lnot A$
V	F
F	V

Primeiramente, treine-o utilizando uma análise geométrica. Depois, implemente o algoritmo de treinamento perceptron para treinar os parâmetros do modelo.

E. 2.1.4.

Crie um perceptron que emule a operação booleana $\lnot\land$ (nand-lógico).

$A_{1}$	$A_{2}$	$\lnot(A_{1}\land A_{2})$
V	V	F
V	F	V
F	V	V
F	F	V

Primeiramente, treine-o utilizando uma análise geométrica. Depois, implemente o algoritmo de treinamento perceptron para treinar os parâmetros do modelo.

E. 2.1.5.

Crie um perceptron que emule a operação booleana $\lnot\lor$ (nor-lógico).

$A_{1}$	$A_{2}$	$\lnot(A_{1}\lor A_{2})$
V	V	F
V	F	F
F	V	F
F	F	V

Primeiramente, treine-o utilizando uma análise geométrica. Depois, implemente o algoritmo de treinamento perceptron para treinar os parâmetros do modelo.

E. 2.1.6.

Busque criar um perceptron que emule a operação lógica do xor.

$A_{1}$	$A_{2}$	$A_{1}\texttt{ xor }A_{2}$
V	V	F
V	F	V
F	V	V
F	F	F

É possível? Justifique sua resposta.

E. 2.1.7.

Crie um perceptron para classificar os seguintes dados

$x_{0}$	$x_{1}$	$x_{2}$	$y$
1.0	1.0	0.0	1
1.0	0.5	0.5	1
0.8	0.2	0.0	1
0.0	0.0	0.0	-1
0.2	0.1	0.0	-1
-0.5	0.4	0.2	-1

Treine-o utilizando o algoritmo de treinamento perceptron. Então, faça a interpretação geométrica do modelo encontrado.

E. 2.1.8.

No E.2.1.6, vimos que não é possível criar um perceptron para emular a operação lógica do xor. Assumindo que $1$ esteja associado ao valor $V$ e $-1$ ao valor $-1$ , podemos contornar esta limitação adicionando uma nova entrada $x_{3}$ ao modelo, que seja dada por $x_{3}=x_{0}x_{1}$ . Verifique e explique como isso é possível. Implemente o modelo e treine-o utilizando o algoritmo de treinamento perceptron.

E. 2.1.9.

Dado um perceptron $\tilde{y}=\mathcal{N}(\boldsymbol{x};\boldsymbol{\theta})$ . Mostre que o valor absoluto de

y\frac{\boldsymbol{\theta}\cdot\tilde{\boldsymbol{x}}}{\|\boldsymbol{\theta}\|}

(2.31)

é a distância do ponto $\tilde{\boldsymbol{x}}$ à reta dada por $\boldsymbol{\theta}\cdot\tilde{\boldsymbol{x}}=0$ . Ainda, mostre que o sinal de (2.31) está associado ao semiplano onde o ponto $\tilde{\boldsymbol{x}}$ está localizado.

E. 2.1.10.

Considerando um conjunto de dados linearmente separáveis, verifique que o algoritmo de treinamento perceptron é convergente para uma escolha arbitrária de parâmetros iniciais.Faça a devida modificação no código do Código 2 e verifique a convergência do algoritmo para diferentes escolhas de parâmetros iniciais.

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Política de uso de dados

Política de uso de dados

Deep Learning para Equações Diferenciais Parciais

2.1 Unidade de processamento

2.1.1 Um problema de classificação

Modelo

Pré-processamento

Treinamento

Implementação

2.1.2 Algoritmo de treinamento: perceptron

Teorema 2.1.1.(Perceptron)

Demonstração.

Aplicação

2.1.3 Exercícios

E. 2.1.1.

E. 2.1.2.

E. 2.1.3.

E. 2.1.4.

E. 2.1.5.

E. 2.1.6.

E. 2.1.7.

E. 2.1.8.

E. 2.1.9.

E. 2.1.10.

Envie seu comentário