Introdução a PINNs

2 Redes neurais feedforward 2 Redes neurais feedforward 2.2 Treinamento por retropropagação

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

2.1 Unidade de processamento

A unidade básica de processamento¹¹1A unidade básica de processamento de uma RNA também é chamada de neurônio artificial ou nodo da rede. do tipo perceptron segue o esquema apresentado na Figura 2.1.

Refer to caption — Figura 2.1: Unidade básica de processamento do tipo perceptron: $y=\eta(\bm{x};\bm{\theta})$ .

Consiste na composição de uma função de ativação²²2Originalmente, 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:=\bm{w}\cdot\bm{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 $\bm{x}=(x_{0},x_{1},\dotsc,x_{n_{\text{in}}-1})\in\mathbb{R}^{n_{\text{in}}}$ é o vetor de entrada, $\bm{\theta}=(\bm{w},b)\in\mathbb{R}^{n_{\text{in}}+1}$ são os parâmetros da unidade, formados pelos pesos $\bm{w}=(w_{0},w_{1},\dotsc,w_{n_{\text{in}}-1})\in\mathbb{R}^{n_{\text{in}}}$ e pelo 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=\eta(\bm{x};\bm{\theta}):=\varphi(z)$		(2.3)
	$\displaystyle\text{}\quad=\varphi(\bm{w}\cdot\bm{x}+b)$		(2.4)

O treinamento (calibração) consiste em determinar os parâmetros $\bm{\theta}$ de forma que o neurônio forneça as saídas $y$ esperadas com base em um critério predeterminado.

2.1.1 Um problema de classificação

O perceptron é um classificador linear, i.e., é capaz de classificar dados que sejam linearmente separáveis. Como aplicação deste fato que demonstraremos mais adiante, vamos criar um perceptron que emule a operação booleana³³3George Boole, 1815 - 1864, matemático britânico. Fonte: Wikipédia: George Boole. $\land$ (e-lógico). Para tanto, precisamos definir o problema, os dados originais de treinamento, o modelo do perceptron, o pré-processamento dos dados, o método de treinamento e, por fim, realizar a implementação do modelo.

Problema e dados de treinamento

Dados dois valores booleanos $A_{1}$ e $A_{2}$ ( $V$ , verdadeiro ou $F$ , falso), esperamos que nossa unidade de processamento forneça como saída o valor booleano $R=A_{1}\land A_{2}$ . Para isso, precisamos de um conjunto de dados de treinamento e de um critério de treinamento. Como dados, podemos usar a tabela verdade do e-lógico (consultemos aTabela 2.1). Esta tabela nos fornece um conjunto de dados de entrada e de saídas esperadas. O critério de treinamento será definido mais adiante.

Tabela 2.1: Tabela verdade da operação booleana

\land

(e-lógico).

$A_{1}$	$A_{2}$	$R:=A_{1}\land A_{2}$
$V$	$V$	$V$
$V$	$F$	$F$
$F$	$V$	$F$
$F$	$F$	$F$

Modelo

Nosso modelo será um perceptron

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% y=\eta(\bm{x};\bm{\theta}),$		(2.5)
	$\displaystyle\text{}\quad\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}% {rgb}{0,0,1}=\operatorname{sign}(\bm{w}\cdot\bm{x}+b),$		(2.6)

com entradas $\bm{x}=(x_{0},x_{1})\in\{-1,1\}^{2}$ , $n_{\text{in}}=2$ , função sinal

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

(2.7)

como função de ativação, saída $y\in\{-1,0,1\}$ e parâmetros a determinar $\bm{\theta}=(w_{0},w_{1},b)\in\mathbb{R}^{3}$ .

Pré-processamento

O pré-processamento dos dados de treinamento consiste em compatibilizá-los com o modelo. No caso em estudo, podemos assumir que o valor booleano $F$ (falso) seja associado a $-1$ e que valor booleano $V$ (verdadeiro) a $1$ . Com isso, os dados de treinamento originais podem ser reescritos como na Tabela 2.2. Denotaremos o conjunto de treinamento pré-processado por $\{\bm{x}^{(s)},y^{(s)}\}_{s=0}^{n_{s}-1}$ , onde $n_{s}=4$ é o número de amostras, $\bm{x}^{(s)}=(x_{0}^{(s)},x_{1}^{(s)})$ é o vetor de entrada da $s$ -ésima amostra e $y^{(s)}$ é a saída esperada para a $s$ -ésima amostra.

Tabela 2.2: Dados de treinamento pré-processados para o treinamento do modelo do e-lógico.

$s$	$x^{(s)}_{0}$	$x^{(s)}_{1}$	$y^{(s)}$
$0$	$1$	$1$	$1$
$1$	$1$	$-1$	$-1$
$2$	$-1$	$1$	$-1$
$3$	$-1$	$-1$	$-1$

Treinamento

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

Lembrando que nosso modelo é

\displaystyle\eta\left(\bm{x};\bm{\theta}\right)=\operatorname{sign}(\color[% rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}w_{0}x_{0}+w_{1}x_{1% }+b),

(2.8)

observamos que

\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% w_{0}x_{0}+w_{1}x_{1}+b=0

(2.9)

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^{+}=\{\bm{x}\in\mathbb{R}^{2}:w_{0}x_{0}+w_{1}x_{1}+b>0\}$		(2.10)
	$\displaystyle\tau^{-}=\{\bm{x}\in\mathbb{R}^{2}:w_{0}x_{0}+w_{1}x_{1}+b<0\}$		(2.11)

O primeiro está no sentido do vetor normal à reta $\bm{w}=(w_{0},w_{1})$ e o segundo no sentido oposto. Com isso, o problema de treinamento se reduz a encontrar os coeficientes da reta

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

(2.12)

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

Com base nessa interpretação geométrica, podemos escolher os parâmetros $\bm{\theta}=(\bm{w},b)$ do nosso modelo. Por exemplo, escolhendo $\bm{w}=(1,1)$ e $b=-1$ , temos o modelo

\displaystyle\eta(\bm{x})=\operatorname{sign}(x_{0}+x_{1}-1)

(2.13)

Verifique que o modelo fornece a saída esperada para cada entrada $\bm{x}$ da Tabela 2.2!

Implementação

O Código 1 é uma implementação do modelo que criamos. 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 do modelo para fazer a classificação de dados linearmente separáveis. Trata-se de um método para o treinamento supervisionado de um modelo, i.e., a calibração dos pesos é feita com base em um conjunto de amostras de treinamento que contém pares de entradas e saídas esperadas.

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

1.

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

onde, $n_{e}$ é um dado número de épocas. Usualmente, uma época é definida como o 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 $\bm{\tilde{x}}=(x_{0},x_{1},\dotsc,x_{n_{\text{in}}-1},1)$ . Com isso, um conjunto $D=\{\bm{\tilde{x}}^{(s)},y^{(s)}\}_{s=0}^{n_{s}-1}$ é linearmente separável, se existe $\bm{\theta}$ tal que

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

(2.14)

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=\{\bm{\tilde{x}}^{(s)},y^{(s)}\}_{s=0}^{n_{s}-1}$ , onde $n_{s}$ é o número de amostras. Se existe $\bm{\theta}^{*}$ tal que

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

(2.15)

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

Demonstração.

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

	$\displaystyle\cos(\beta)=\frac{\bm{\theta}^{(k)}\cdot\bm{\theta}^{}}{\\|\bm{% \theta}^{(k)}\\|\\|\bm{\theta}^{}\\|}$		(2.16)
	$\displaystyle\text{}\quad=\frac{\bm{\theta}^{(k)}\cdot\bm{\theta}^{}}{\\|\bm{% \theta}^{}\\|}\frac{1}{\\|\bm{\theta}^{(k)}\\|}.$		(2.17)

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)}\bm{\theta}^{(k-1)}\cdot\tilde{\bm{x}}^{(s)}\leq 0$ . Com isso, temos

	$\displaystyle\frac{\bm{\theta}^{(k)}\cdot\bm{\theta}^{}}{\\|\bm{\theta}^{}\\|}% =\frac{(\bm{\theta}^{(k-1)}+y^{(s)}\tilde{\bm{x}}^{(s)})\cdot\bm{\theta}^{}}{% \\|\bm{\theta}^{}\\|}$		(2.18)
	$\displaystyle\text{}\quad=\frac{\bm{\theta}^{(k-1)}\cdot\bm{\theta}^{}}{\\|\bm% {\theta}^{}\\|}+y^{(s)}\frac{\tilde{\bm{x}}^{(s)}\cdot\bm{\theta}^{}}{\\|\bm{% \theta}^{}\\|}$		(2.19)
	$\displaystyle\text{}\quad\geq\frac{\bm{\theta}^{(k-1)}\cdot\bm{\theta}^{}}{\\|% \bm{\theta}^{}\\|}+\gamma$		(2.20)
	$\displaystyle\text{}\quad\geq k\gamma,$		(2.21)

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

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

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.26)

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.

Seja um perceptron com função sinal como função de ativação e parâmetros $\bm{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). Treine o modelo utilizando:

a)

uma análise geométrica;
b)

o algoritmo de treinamento perceptron.

E. 2.1.3.

Crie um perceptron que emule a operação booleana do $\lnot$ (negação-lógico). Treine o modelo utilizando:

a)

uma análise geométrica;
b)

o algoritmo de treinamento perceptron.

E. 2.1.4.

Crie um perceptron que emule a operação booleana $\lnot\land$ (negação do e-lógico). Treine o modelo utilizando:

a)

uma análise geométrica;
b)

o algoritmo de treinamento perceptron.

E. 2.1.5.

Busque criar um perceptron que emule a operação lógica do xor (ou-exclusivo-lógico). É possível? Justifique sua resposta.

Tabela 2.3: Tabela verdade da operação booleana xor (ou-exclusivo-lógico).

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

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