Log_Loss_Cross_Entropy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNumx6C3dWibiKS7h8r+ryk",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SampMark/Machine-Learning/blob/main/Log_Loss_Cross_Entropy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **A Função de Custo de Entropia Cruzada (Cross-Entropy Loss) $ J(\\theta) $**\n",
        "\n",
        "A função de custo para cálculo da entropia cruzada (Cross-Entropy Loss) é usada em **aprendizado de máquina** em modelos de **classificação multiclasse**, como na [**Regressão Softmax**](https://github.com/SampMark/Machine-Learning/blob/main/Softmax_Multinomial_Regression.ipynb) e incorpora **regularização**, o que a torna ideal para problemas de classificação com múltiplas classes.  Ou seja, ela combina **entropia cruzada multiclasse** com **regularização $L2$**, sendo amplamente utilizada em problemas de classificação com múltiplas classes.\n",
        "\n",
        "A função de custo de entropia cruzada com regularização L2 é fundamental em modelagens com redes neurais e aprendizado profundo, sendo usada como base para a classificação em redes neurais convolucionais (CNN) e modelos de Processamento de Lingugem Natural (NLP) como Transformers. Em linhas gerais, tem por objetivo medir a discrepância entre as probabilidades previstas pelo modelo e as classes reais. Minimizar a função melhora a precisão do modelo e evita sobreajuste.\n",
        "\n",
        "## **Definição matemática**\n",
        "A função de custo $J(\\theta)$ é uma combinação convexa de:\n",
        "1. **Função de Perda (Entropia Cruzada):** para medir o ajuste aos dados.\n",
        "2. **Regularização \\(L_2\\):** para controlar a complexidade do modelo.\n",
        "\n",
        "$$\n",
        "J(\\theta) = -\\underbrace{\\frac{1}{n} \\left[ \\sum_{i=1}^{n} \\sum_{j=0}^{k-1} \\mathbf{1}[y^{(i)} = j] \\log \\frac{e^{\\theta_j \\cdot x^{(i)}/\\tau}}{\\sum_{l=0}^{k-1} e^{\\theta_l \\cdot x^{(i)}/\\tau}} \\right]}_{\\text{Entropia Cruzada}} + \\underbrace{\\frac{\\lambda}{2} \\sum_{j=0}^{k-1} \\sum_{s=0}^{d-1} \\theta_{js}^2}_{\\text{Regularização } L_2}\n",
        "$$\n",
        "\n",
        "onde:\n",
        "- $ n $ é o número total de exemplos de treinamento,\n",
        "- $ k $ é o número de classes distintas,\n",
        "- $ d $ é o número de características por amostra,\n",
        "- $ x^{(i)} $ representa o vetor de características da $ i $-ésima amostra,\n",
        "- $ y^{(i)} $ é a classe verdadeira da $ i $-ésima amostra,\n",
        "- $ \\theta_j $ é o vetor de pesos para a classe $ j $,\n",
        "- $ \\tau $ é um **parâmetro de temperatura**, que pode ser usado para controlar a suavização da distribuição de probabilidade (comum em modelos de aprendizado profundo),\n",
        "- $ \\lambda $ é um hiperparâmetro de **regularização**.\n",
        "\n",
        "### **Termo Principal: Log Loss (_Cross-Entropy_)**\n",
        "O primeiro termo da função de custo é a **entropia cruzada (cross-entropy loss)**, amplamente utilizada para classificação multiclasse. Ele mede o quão bem o modelo atribui probabilidades corretas às classes reais.\n",
        "\n",
        "$$\n",
        "-\\frac{1}{n} \\sum_{i=1}^{n} \\sum_{j=0}^{k-1} \\mathbf{1}[y^{(i)} = j] \\log P(y^{(i)} = j | x^{(i)})\n",
        "$$\n",
        "\n",
        "onde:\n",
        "\n",
        "$$\n",
        "P(y^{(i)} = j | x^{(i)}) = \\frac{e^{\\theta_j \\cdot x^{(i)}/\\tau}}{\\sum_{l=0}^{k-1} e^{\\theta_l \\cdot x^{(i)}/\\tau}}\n",
        "$$\n",
        "\n",
        "Essa fração representa a **função softmax**, que converte os valores de ativação linear ($ \\theta \\cdot x $) em probabilidades.\n",
        "\n",
        "### **Termo de Regularização**\n",
        "O segundo termo:\n",
        "\n",
        "$$\n",
        "\\frac{\\lambda}{2} \\sum_{j=0}^{k-1} \\sum_{s=0}^{d-1} \\theta_{js}^2\n",
        "$$\n",
        "\n",
        "é uma **regularização L2 (Ridge Regularization)**, que penaliza grandes valores de $ \\theta $ para evitar **overfitting**. Ele incentiva o modelo a aprender pesos menores e mais estáveis.\n",
        "\n",
        "## **Relação com Regressão Logística Softmax**\n",
        "A [**Regressão Logística Softmax**](https://github.com/SampMark/Machine-Learning/blob/main/Softmax_Multinomial_Regression.ipynb) estende a regressão logística binária para múltiplas classes. Para um conjunto de dados de classificação com $ k $ classes, a função softmax converte os escores do modelo em probabilidades:\n",
        "\n",
        "$$\n",
        "P(y=j | x, \\theta) = \\frac{e^{\\theta_j \\cdot x}}{\\sum_{l=0}^{k-1} e^{\\theta_l \\cdot x}}\n",
        "$$\n",
        "\n",
        "Isso garante que a soma das probabilidades seja 1, permitindo que o modelo seja interpretado como um **classificador probabilístico**.\n",
        "\n",
        "\n",
        "## **Comparação com Outras Funções de Custo**\n",
        "1. **Erro Quadrático Médio (MSE)**:  \n",
        "   - Funciona bem para **regressão**, mas não é ideal para **classificação**, pois trata classes como valores contínuos.\n",
        "   \n",
        "2. **Cross-Entropy Loss (para classificação binária)**:  \n",
        "   - Similar à softmax, mas aplicada a **dois rótulos**.\n",
        "\n",
        "3. [**Hinge Loss (SVMs)**](https://github.com/SampMark/Machine-Learning/blob/main/Hinge_Loss.ipynb):  \n",
        "   - Em vez de probabilidades, trabalha com **margens de decisão**.\n",
        "\n",
        "A função softmax é preferida para problemas **multiclasse**, já que garante que cada entrada seja classificada corretamente com uma probabilidade associada.\n",
        "\n",
        "---\n"
      ],
      "metadata": {
        "id": "qySYcsgU-sVO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Importando as bibliotecas\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "UWdgF4qtDRGl"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **🎯Implementação em Python**\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "45-oUuwgDiV5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title **Função de custo para a regressão logística Softmax com regularização L2**\n",
        "def compute_cost_function(X: np.ndarray, Y: np.ndarray, theta: np.ndarray,\n",
        "                          lambda_factor: float, temp_parameter: float = 1.0) -> float:\n",
        "    \"\"\"\n",
        "    Calcula a função de custo para a regressão logística Softmax com regularização L2.\n",
        "\n",
        "    Args:\n",
        "        X (np.ndarray): Matriz de características com shape (n_amostras, n_features).\n",
        "        Y (np.ndarray): Vetor de rótulos inteiros com shape (n_amostras,).\n",
        "        theta (np.ndarray): Matriz de pesos do modelo com shape (n_classes, n_features).\n",
        "        lambda_factor (float): Fator de regularização para penalização L2.\n",
        "        temp_parameter (float, opcional): Parâmetro de temperatura para escalonamento. Padrão é 1.0.\n",
        "\n",
        "    Returns:\n",
        "        float: Valor da função de custo.\n",
        "    \"\"\"\n",
        "\n",
        "    # Número de amostras e dimensões dos dados\n",
        "    n, d = X.shape  # n = número de amostras, d = número de características\n",
        "    k = theta.shape[0]  # Número de classes\n",
        "\n",
        "    # Verificações das entradas\n",
        "    assert Y.shape[0] == n, \"Erro: Y deve ter o mesmo número de linhas que X.\"\n",
        "    assert theta.shape[1] == d, \"Erro: theta deve ter o mesmo número de colunas que X.\"\n",
        "    assert isinstance(lambda_factor, float) and lambda_factor >= 0, \"Erro: lambda_factor deve ser um número positivo.\"\n",
        "\n",
        "    # Cálculo dos logits escalonados: θX / temp_parameter\n",
        "    logits = np.dot(X, theta.T) / temp_parameter  # Shape: (n, k)\n",
        "\n",
        "    # Estabilização numérica: subtrai o máximo dos logits para evitar overflow\n",
        "    logits -= np.max(logits, axis=1, keepdims=True)\n",
        "\n",
        "    # Aplicação da função Softmax\n",
        "    exp_logits = np.exp(logits)\n",
        "    softmax_probs = exp_logits / np.sum(exp_logits, axis=1, keepdims=True)\n",
        "\n",
        "    # One-hot encoding dos rótulos\n",
        "    y_onehot = np.eye(k)[Y.flatten()]  # Shape: (n, k)\n",
        "\n",
        "    # Probabilidades das classes corretas\n",
        "    correct_class_probs = np.sum(softmax_probs * y_onehot, axis=1)\n",
        "\n",
        "    # Cálculo da entropia cruzada (evita log(0) com np.clip)\n",
        "    cross_entropy = -np.mean(np.log(np.clip(correct_class_probs, 1e-10, 1.0)))\n",
        "\n",
        "    # Regularização L2\n",
        "    regularization = (lambda_factor / 2) * np.sum(theta ** 2)\n",
        "\n",
        "    # Função de custo final\n",
        "    cost = cross_entropy + regularization\n",
        "\n",
        "    return cost"
      ],
      "metadata": {
        "id": "n9E5N8lMHFru"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **📌 Explicação do Código**\n",
        "\n",
        "#### **1️⃣ Cálculo dos Logits**\n",
        "```python\n",
        "logits = np.dot(X, theta.T) / temp_parameter\n",
        "```\n",
        "- Multiplicação da matriz de características $X$ pelos pesos $\\theta$, ajustados pelo **parâmetro de temperatura**.\n",
        "- **Objetivo**: transformar as características em escores que representam a força da previsão para cada classe.\n",
        "\n",
        "#### **2️⃣ Estabilização Numérica**\n",
        "```python\n",
        "logits -= np.max(logits, axis=1, keepdims=True)\n",
        "```\n",
        "- **Por quê?** Em aprendizado de máquina, os expoentes podem crescer muito, levando a `overflow numérico`, logo, subtrair o máximo evita esse problema.\n",
        "\n",
        "#### **3️⃣ Aplicação da Softmax**\n",
        "```python\n",
        "exp_logits = np.exp(logits)\n",
        "softmax_probs = exp_logits / np.sum(exp_logits, axis=1, keepdims=True)\n",
        "```\n",
        "- **Função Softmax** converte os logits em probabilidades entre 0 e 1.\n",
        "- **Objetivo**: Garante que a soma das probabilidades para cada amostra seja 1.\n",
        "\n",
        "#### **4️⃣ Criação do One-Hot Encoding**\n",
        "```python\n",
        "y_onehot = np.eye(k)[Y.flatten()]\n",
        "```\n",
        "- Gera uma matriz **one-hot encoded** para os rótulos de classe \\( Y \\).\n",
        "- Se \\( k=3 \\) e \\( Y=[0, 2, 1] \\), então:\n",
        "  ```python\n",
        "  y_onehot = [[1, 0, 0],  # Classe 0\n",
        "              [0, 0, 1],  # Classe 2\n",
        "              [0, 1, 0]]  # Classe 1\n",
        "  ```\n",
        "\n",
        "#### **5️⃣ Cálculo da Entropia Cruzada**\n",
        "```python\n",
        "correct_class_probs = np.sum(softmax_probs * y_onehot, axis=1)\n",
        "cross_entropy = -np.mean(np.log(np.clip(correct_class_probs, 1e-10, 1.0)))\n",
        "```\n",
        "- **Objetivo**: Penaliza predições erradas através do logaritmo das probabilidades corretas.\n",
        "- **Por que `np.clip`?** Evita `log(0)`, que geraria `-inf`.\n",
        "\n",
        "#### **6️⃣ Regularização L2**\n",
        "```python\n",
        "regularization = (lambda_factor / 2) * np.sum(theta ** 2)\n",
        "```\n",
        "- Penaliza grandes valores de $\\theta$, evitando **overfitting**.\n",
        "\n",
        "### **7️⃣ Cálculo da Função de Custo Final**\n",
        "```python\n",
        "cost = cross_entropy + regularization\n",
        "```\n",
        "- Soma a entropia cruzada e a penalização $L2$."
      ],
      "metadata": {
        "id": "S8kfLtnDIcmk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Exemplo 1 - Classificação de Dígitos (MNIST Simples)**\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "A seguir uma simulação simples num conjunto de dados de classificação de dígitos manuscritos (como MNIST), num cenário típico de um classificador de dígitos manuscritos com **10 classes (0 a 9)** e um conjunto de características aleatórias. A função de custo avalia a performance inicial do modelo antes do treinamento."
      ],
      "metadata": {
        "id": "fBzuxAwNKRU1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title **Simulação de um conjunto de dados MNIST**\n",
        "np.random.seed(42)  # Para reprodutibilidade\n",
        "\n",
        "n_samples = 1000   # Número de exemplos\n",
        "n_features = 784   # Características (como pixels de uma imagem 28x28)\n",
        "n_classes = 10     # Dígitos de 0 a 9\n",
        "\n",
        "# Gera características aleatórias normalizadas\n",
        "X = np.random.rand(n_samples, n_features)\n",
        "\n",
        "# Gera rótulos aleatórios entre 0 e 9\n",
        "Y = np.random.randint(0, n_classes, size=(n_samples,))\n",
        "\n",
        "# Inicializa pesos aleatórios\n",
        "theta = np.random.randn(n_classes, n_features) * 0.01\n",
        "\n",
        "# Define hiperparâmetros\n",
        "lambda_factor = 0.1  # Regularização\n",
        "temp_parameter = 1.0  # Parâmetro de temperatura para softmax\n",
        "\n",
        "# Cálculo do custo\n",
        "cost = compute_cost_function(X, Y, theta, lambda_factor, temp_parameter)\n",
        "print(f\"Função de custo (MNIST Simulado): {cost:.4f}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jSzL2VFUJO3U",
        "outputId": "b1d941b0-d693-4b00-9f24-de9b7fd47a7b"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Função de custo (MNIST Simulado): 2.3604\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Exemplo 2 - Classificação de Sentimentos/Opniões (Análise de Texto)**\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Neste segundo exemplo, utilizamos um conjunto de dados **bag-of-words** para classificar sentimentos/opiniões extraídas de comentários (positivo, neutro, negativo). Uma aplicação da **função de custo em PLN** (Processamento de Linguagem Natural), em que matriz `X` representa um **modelo de Bag-of-Words** (frequência de palavras) e a função de custo fornece um indicativo de quão bem o modelo inicial está classificado os sentimentos/opiniões sobre produtos/serviços, entre outras aplicações."
      ],
      "metadata": {
        "id": "ylmpsidqK5qK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Simulação de um dataset de análise de sentimentos\n",
        "np.random.seed(123)\n",
        "\n",
        "n_samples = 500    # Número de frases analisadas\n",
        "n_features = 300   # Número de características (palavras)\n",
        "n_classes = 3      # Classes: [0 = negativo, 1 = neutro, 2 = positivo]\n",
        "\n",
        "# Características de frequência de palavras\n",
        "X = np.random.rand(n_samples, n_features)\n",
        "\n",
        "# Rótulos para sentimentos (negativo, neutro, positivo)\n",
        "Y = np.random.randint(0, n_classes, size=(n_samples,))\n",
        "\n",
        "# Inicializa pesos do modelo\n",
        "theta = np.random.randn(n_classes, n_features) * 0.01\n",
        "\n",
        "# Parâmetros de treinamento\n",
        "lambda_factor = 0.05\n",
        "temp_parameter = 1.0\n",
        "\n",
        "# Calculando o custo\n",
        "cost = compute_cost_function(X, Y, theta, lambda_factor, temp_parameter)\n",
        "print(f\"Função de custo (Análise de Sentimentos): {cost:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_wTQXMjfJx93",
        "outputId": "911bacc0-973f-4061-d9ac-c5ea8f084427"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Função de custo (Análise de Sentimentos): 1.1054\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Referências**\n",
        "\n",
        "* GOODFELLOW, I.; BENGIO, Y.; COURVILLE, A. **Deep Learning**. Cambridge: MIT Press, 2016. Capítulo sobre redes neurais e otimização. Disponível em: [https://www.deeplearningbook.org/](https://www.deeplearningbook.org/). Acesso em: 26 de fev. 2025.\n",
        "\n"
      ],
      "metadata": {
        "id": "rF7s6Grp_X_2"
      }
    }
  ]
}