Introdução

As redes neurais profundas revolucionaram diversas áreas da tecnologia, desde o reconhecimento de imagens até o processamento de linguagem natural. Neste artigo, exploraremos os fundamentos matemáticos que sustentam essas poderosas ferramentas de aprendizado de máquina.

O Neurônio Artificial

O neurônio artificial é a unidade básica de uma rede neural. Matematicamente, podemos representá-lo como uma função que recebe múltiplas entradas, aplica pesos a essas entradas, soma os resultados e passa essa soma por uma função de ativação.

\[ y = f\left(\sum_{i=1}^{n} w_i x_i + b\right) = f(w^T x + b) \]

Onde:

1. X_i são as entradas

2. w_i são os pesos associados a cada entrada

3. b é o termo de viés (bias)

4. f é a função de ativação

5. y é a saída do neurônio

Funções de Ativação

As funções de ativação introduzem não-linearidades no modelo, permitindo que a rede neural aprenda padrões complexos. Algumas das funções de ativação mais comuns incluem:

Sigmoid

\[ \sigma(z) = \frac{1}{1 + e^{-z}} \]

A função sigmoid comprime a saída para o intervalo $(0,1)$, sendo útil para problemas que envolvem probabilidades.

ReLU (Rectified Linear Unit)

\[ \text{ReLU}(z) = \max(0, z) \]

A ReLU é computacionalmente eficiente e ajuda a mitigar o problema do desaparecimento do gradiente.

Tangente Hiperbólica

\[ \tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}} \]

A tangente hiperbólica produz saídas no intervalo $(-1,1)$ e possui propriedades semelhantes à sigmoid.

Arquitetura de Redes Neurais Profundas

Uma rede neural profunda consiste em múltiplas camadas de neurônios conectados entre si. Temos:

1. Camada de entrada: Recebe os dados iniciais

2. Camadas ocultas: Realizam transformações nos dados

3. Camada de saída: Produz o resultado final

\[ \]

Matematicamente, a propagação direta (forward propagation) através de uma rede neural com $L$ camadas pode ser expressa como:

\[ a^{[0]} = X \]
\[ z^{[l]} = W^{[l]} a^{[l-1]} + b^{[l]} \]
\[ a^{[l]} = g^{[l]}(z^{[l]}) \]
\[ \hat{y} = a^{[L]} \]

Onde:

1. a^{[l]} é a ativação da camada

2. W^{[l]} é a matriz de pesos da camada

3. b^{[l]} é o vetor de viés da camada

g^{[l]} é a função de ativação da camada

\hat{y} é a previsão final da rede

O treinamento de redes neurais ocorre através do algoritmo de retropropagação (backpropagation), que calcula os gradientes para atualizar os pesos e vieses da rede. O processo inicia calculando o erro entre a saída prevista $\hat{y}$ e o valor real $y$:

\[ J(W, b) = \frac{1}{m} \sum_{i=1}^{m} L(\hat{y}^{(i)}, y^{(i)}) \]

Onde $L$ é uma função de perda apropriada, como a entropia cruzada para classificação ou erro quadrático médio para regressão. O algoritmo de backpropagation usa a regra da cadeia para calcular os gradientes:

\[ \frac{\partial J}{\partial W^{[l]}} = \frac{1}{m} dZ^{[l]} (a^{[l-1]})^T \]
\[ \frac{\partial J}{\partial b^{[l]}} = \frac{1}{m} \sum_{i=1}^{m} dZ^{[l]} \]
\[ dZ^{[l]} = dA^{[l]} * g'^{[l]}(Z^{[l]}) \]
\[ dA^{[l-1]} = (W^{[l]})^T dZ^{[l]} \]

Os pesos e vieses são então atualizados usando um algoritmo de otimização, como o Gradiente Descendente:

\[ W^{[l]} := W^{[l]} - \alpha \frac{\partial J}{\partial W^{[l]}} \]
\[ b^{[l]} := b^{[l]} - \alpha \frac{\partial J}{\partial b^{[l]}} \]

Onde $\alpha$ é a taxa de aprendizado.

Regularização

Para evitar o overfitting, técnicas de regularização são aplicadas. A regularização L2, por exemplo, adiciona um termo à função de custo:

\[ J_{regularizado}(W, b) = J(W, b) + \frac{\lambda}{2m} \sum_{l=1}^{L} ||W^{[l]}||^2_F \]

Onde $\lambda$ é o parâmetro de regularização e $||W||^2_F$ é a norma de Frobenius da matriz de pesos. Outras técnicas incluem Dropout, onde neurônios são aleatoriamente desativados durante o treinamento:

\[ a^{[l]} = g^{[l]}(z^{[l]}) * d^{[l]} \]
\[ d^{[l]} \sim \text{Bernoulli}(p) \]

Redes Neurais Convolucionais (CNNs)

As CNNs são especialmente eficazes para processamento de imagens. A operação de convolução é definida como:

\[ (f * g)(t) = \int_{-\infty}^{\infty} f(\tau) g(t - \tau) d\tau \]

Em redes neurais, a convolução discreta 2D é utilizada:

\[ (I * K)(i, j) = \sum_{m} \sum_{n} I(i+m, j+n) K(m, n) \]

Onde $I$ é a imagem de entrada e $K$ é o kernel.

Redes Neurais Recorrentes (RNNs)

As RNNs são projetadas para processar sequências temporais, mantendo um estado interno:

\[ h_t = g(W_{hx} x_t + W_{hh} h_{t-1} + b_h) \]
\[ y_t = W_{yh} h_t + b_y \]

Onde:

1. $h_t$ é o estado oculto no tempo $t$

2. $x_t$ é a entrada no tempo $t$

3. $y_t$ é a saída no tempo $t$

4. $W_{hx}$, $W_{hh}$, $W_{yh}$ são matrizes de peso

5. $b_h$, $b_y$ são vetores de viés

LSTMs e GRUs

\[ f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \]
\[ i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \]
\[ \tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C) \]
\[ C_t = f_t * C_{t-1} + i_t * \tilde{C}_t \]
\[ o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) \]
\[ h_t = o_t * \tanh(C_t) \]

Redes Generativas Adversariais (GANs)

As GANs consistem em dois componentes: um gerador $G$ e um discriminador $D$. O jogo minimax entre $G$ e $D$ é definido como:

\[ \min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))] \]

Onde:

1. $p_{data}$ é a distribuição dos dados reais

2. $p_z$ é a distribuição do ruído de entrada

3. $G(z)$ é o gerador que mapeia o ruído para dados sintéticos

4. $D(x)$ é o discriminador que estima a probabilidade de $x$ ser real

Conclusão

As redes neurais profundas são estruturas matemáticas complexas que permitem a modelagem de padrões intrincados nos dados. Embora tenhamos abordado apenas os fundamentos, espero que esta introdução matemática ajude a elucidar os princípios por trás dessas poderosas ferramentas de aprendizado de máquina.

Referências

Goodfellow, I., Bengio, Y., Courville, A. (2016). Deep Learning. MIT Press.
LeCun, Y., Bengio, Y., Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444.
Rumelhart, D. E., Hinton, G. E., Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533-536.