Camada de Embedding

A camada Embedding do Keras é utilizada para mapear inteiros (representando palavras ou tokens) em vetores densos de dimensão fixa. É fundamental em tarefas de Processamento de Linguagem Natural (PLN), pois permite que o modelo aprenda representações vetoriais semânticas durante o treinamento.

A assinatura básica da camada é:

keras.layers.Embedding(
    vocab_size,
    embedding_dim,
    embeddings_initializer='uniform',
    embeddings_regularizer=None,
    activity_regularizer=None,
    embeddings_constraint=None,
    mask_zero=False,
    input_length=None
)

Parâmetros principais:

• vocab_size: tamanho do vocabulário, ou seja, a quantidade total de palavras únicas. Se houver um token especial para preenchimento (padding), some 1 ao total.
• embedding_dim: número de dimensões do vetor de saída para cada palavra.
• embeddings_initializer: define a estratégia de inicialização dos pesos da matriz de embeddings.
• mask_zero: quando True, o valor zero (usado para padding) é ignorado nas operações subsequentes. Isso é especialmente útil em sequências de comprimento variável.
• input_length: comprimento fixo das sequências de entrada.

Exemplo simplificado de uso:

from tensorflow.keras.layers import Embedding
from tensorflow.keras.models import Sequential

modelo = Sequential()
modelo.add(Embedding(input_dim=10000, output_dim=128, input_length=50, mask_zero=True))
modelo.summary()

Função de Ativação Softmax

A função softmax é uma generalização da sigmoide para problemas multiclasse. Ela converte um vetor de valores reais em uma distribuição de probabilidade, onde todos os elementos somam 1.

Matematicamente, cada saída é calculada como:

softmax(x_i) = exp(x_i) / soma(exp(x_j)) para todo j

As principais características são:

• Garante valores não negativos, pois a função exponencial sempre retorna valores positivos.
• Normaliza os resultados para que a soma de todas as classes seja igual a 1, facilitnado a interpretação probabilística.

import numpy as np

def calcular_softmax(logits):
    exp_valores = np.exp(logits - np.max(logits))
    probabilidades = exp_valores / np.sum(exp_valores)
    return probabilidades

scores = np.array([2.0, 1.0, 0.1])
resultado = calcular_softmax(scores)
print("Probabilidades:", resultado)
print("Soma:", np.sum(resultado))

Método fit() para Treinamento

O método fit() é responsável por treinar o modelo com os dados fornecidos, iterando sobre o conjunto de treinamento em épocas e lotes (batches).

modelo.fit(
    x_treino,
    y_treino,
    batch_size=64,
    epochs=20,
    verbose=1,
    callbacks=[],
    validation_split=0.2,
    validation_data=None,
    shuffle=True,
    class_weight=None,
    sample_weight=None,
    initial_epoch=0,
    steps_per_epoch=None,
    validation_steps=None,
    validation_freq=1
)

Descrição dos parâmetros mais relevantes:

• x_treino / y_treino: dados de entrada e rótulos correspondentes.
• batch_size: número de amostras processadas antes de cada atualização de gradiente. O valor padrão é 32.
• epochs: número de vezes que o modelo percorre todo o conjunto de treino.
• verbose: controla o nível de detalhamento do progresso exibido no console (0 = silencioso, 1 = barra de progresso, 2 = uma linha por época).
• callbacks: lista de funções de callback executadas em momentos específicos do treinamento, como checkpointing ou early stopping.
• validation_split: fração dos dados de treino reservada para validação (entre 0 e 1).
• validation_data: tupla (x_val, y_val) usada como conjunto de validação. Sobrescreve validation_split.
• shuffle: se True, embaralha os dados antes de cada época.
• steps_per_epoch: total de passos (batches) por época. Útil quando se usa tf.data.Dataset.
• validation_freq: frequência com que a validação é executada (ex.: a cada 1 época).

Método compile() para Configuração do Modelo

Antes do treinamento, o modelo deve ser compilado, especificando o otimizador, a função de perda e as métricas de avaliação.

modelo.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy'],
    loss_weights=None,
    sample_weight_mode=None,
    weighted_metrics=None
)

Principais argumentos:

• optimizer: define o algoritmo de otimização. Pode ser uma string (como 'adam', 'sgd') ou uma instância de uma classe otimizadora. Parâmetros comuns incluem:
  • lr: taxa de aprendizado (learning rate), valor float >= 0.
  • momentum: acelera a convergência na direção relevante, valor float >= 0.
  • decay: decaimento da taxa de aprendizado a cada atualização.
  • nesterov: booleano que indica se o momentum de Nesterov deve ser aplicado.
• loss: função de perda a ser minimizada. Pode ser uma string, uma função customizada, ou uma lista/dicionário quanndo há múltiplas saídas.
• metrics: lista de métricas availadas durante o treino e teste, mas que não influenciam o ajuste dos pesos. Métricas integradas incluem binary_accuracy, categorical_accuracy, sparse_categorical_accuracy e top_k_categorical_accuracy. Métricas personalizadas devem aceitar (y_true, y_pred) e retornar um tensor.
• loss_weights: lista ou dicionário opcional que define os pesos de cada função de perda quando há múltiplas saídas.