Introdução a PINNs

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¹¹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 of 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 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=\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 saída esperada. O critério de treinamento vamos definir 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 dada entrada $\bm{x}$ . Isso consiste em determinar método (de treinamento) para escolhermos os parâmetros $\bm{\theta}$ que sejam adequados para esta tarefa. Vamos explorar mais sobre isso na sequência do texto, sendo que aqui vamos empregar uma análise geométrica para escolhermos 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 1,\dotsc,n_{s}$ :
  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}$ épocas.

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