Inteligência Artificial

Documentação Completa: IA-Experience

01/09/2025

1. Visão Geral: Chega de Magia, Vamos Falar de Mecânica

Se você já ouviu falar de Inteligência Artificial e imaginou uma caixa-preta mística que cospe respostas, você veio ao lugar certo. A verdade, como sempre, é muito mais interessante (e menos assustadora). Uma rede neural não é mágica; ela é um mecanismo. Um mecanismo surpreendentemente simples em suas partes, mas que exibe um comportamento complexo e poderoso quando essas partes trabalham juntas. Como destacado, “por trás de toda a complexidade e do hype, o que encontramos é… um mecanismo de tentativa e erro” (Maltempi, 2024).

A aplicação IA-Experience é sua bancada de testes. Ela foi criada para rasgar o véu e mostrar a engrenagem, a matemática e a lógica que movem o “aprendizado” de máquina. O objetivo aqui não é apenas ver a IA funcionar, mas sim entender por que ela funciona, colocando as mãos na massa, ajustando os parafusos e vendo o motor responder em tempo real. Esta abordagem se alinha com a literatura pedagógica que defende a visualização e a interação como catalisadores para o entendimento de sistemas complexos (Naps et al., 2002).

2. Os Blocos de Construção: Anatomia de uma Rede Neural

Antes de pilotar o avião, precisamos conhecer as peças. Uma rede neural, por mais complexa que pareça, é construída a partir de alguns componentes fundamentais.

2.1. O Neurônio Artificial: O “Operário” da Rede

Pense em um neurônio como um único operário em uma linha de montagem. Ele tem uma tarefa muito específica: receber informações, tomar uma decisão simples com base nelas e passar o resultado adiante. Este conceito é a evolução direta do Perceptron, proposto por Frank Rosenblatt em 1958, que foi um dos primeiros modelos matemáticos de um neurônio.

2.2. A Arquitetura: Montando a Fábrica

3. O Motor do Aprendizado: Como a Rede “Pensa”

A rede não pensa. Ela calcula. O processo de “aprendizado” é um ciclo engenhoso de cálculo e ajuste, conhecido como Backpropagation (Retropropagação do Erro). Este algoritmo, popularizado por Rumelhart, Hinton & Williams (1986), foi o grande salto que permitiu o treinamento eficaz de redes com múltiplas camadas.

4. Mergulhando no Código (app.js)

Agora, vamos abrir o capô e ver como esses conceitos se transformam em código funcional.

4.1. A Célula Fundamental: A Classe Neuron

O conceito de neurônio é materializado em uma class no JavaScript. Ela é o “plano de construção” para cada operário da nossa rede.


class Neuron {
    constructor(numInputs, name, position) {
        this.name = name;
        // 1. Pesos são inicializados com valores aleatórios entre -1 e 1
        this.weights = Array.from({ length: numInputs }, () => Math.random() * 2 - 1);
        // 2. Bias também é inicializado aleatoriamente
        this.bias = Math.random() * 2 - 1;
        this.output = 0;
        // ...
    }

    // 3. A função de ativação Sigmoid
    sigmoid = (x) => 1 / (1 + Math.exp(-x));

    // 4. A derivada da Sigmoid (usada no backpropagation)
    sigmoidDerivative = () => this.output * (1 - this.output); 

    // 5. O processo de FeedForward do neurônio
    feedForward(inputs) {
        const sum = inputs.reduce((acc, input, i) => acc + input * this.weights[i], this.bias);
        this.output = this.sigmoid(sum);
        return this.output;
    }
}
  1. & 2 (Pesos e Bias): No constructor, cada neurônio nasce sem saber de nada, com pesos e bias aleatórios, que é o ponto de partida para o aprendizado.
  2. ** (Sigmoid):** Implementação matemática da função que “esmaga” a saída para um valor entre 0 e 1.
  3. ** (Derivada):** Essencial para o Backpropagation, ajuda a medir a “confiança” do neurônio em sua decisão para modular os ajustes.
  4. ** (FeedForward):** Executa a tarefa do “operário”: recebe inputs, multiplica-os pelos weights, soma o bias e aplica a sigmoid para gerar a output final.

4.2. A Fábrica em Ação: O Backpropagation

A função backpropagateNetwork é o motor do aprendizado, executando o ciclo de treinamento a cada clique no botão “Treinar”.


function backpropagateNetwork(inputs, targetVal) {
    // PASSO 1: O CHUTE (Feedforward)
    const hiddenOutputs = hiddenLayer.map(n => n.feedForward(inputs));
    const predictedOutput = outputNeuron.feedForward(hiddenOutputs);

    // PASSO 2: A REALIDADE (Cálculo do Erro)
    const error = targetVal - predictedOutput;

    // PASSO 3: O DETETIVE (Backpropagation)
    outputNeuron.delta = error * outputNeuron.sigmoidDerivative(); // Culpa da saída
    hiddenLayer.forEach((hiddenN, hIndex) => { // Distribuição da culpa
        hiddenN.delta = outputNeuron.delta * outputNeuron.weights[hIndex] * hiddenN.sigmoidDerivative();
    });

    // PASSO 4: O AJUSTE (Atualização dos Pesos e Vieses)
    outputNeuron.weights.forEach((w, i) => { 
        outputNeuron.weights[i] += learningRate * outputNeuron.delta * hiddenOutputs[i]; 
    });
    outputNeuron.bias += learningRate * outputNeuron.delta;

    hiddenLayer.forEach((hiddenN) => { // Ajuste da camada oculta
        hiddenN.weights.forEach((w, iIndex) => { 
            hiddenN.weights[iIndex] += learningRate * hiddenN.delta * inputs[iIndex]; 
        });
        hiddenN.bias += learningRate * hiddenN.delta;
    });
}

Este bloco de código é a tradução literal do algoritmo. O error é usado para calcular o delta (a culpa), que por sua vez é usado para ajustar os weights e bias de cada neurônio, sempre modulado pela learningRate.

4.3. A Bancada de Testes: O Modo de Simulação de Neurônio

A função switchToNeuronView é a alma da proposta interativa da ferramenta, permitindo isolar e manipular um único neurônio diretamente.


function switchToNeuronView() {
    simulationMode = 'neuron'; // Muda o modo da aplicação
    // ...
    // Para cada PESO do neurônio selecionado, cria um slider de controle
    selectedNeuron.weights.forEach((weightValue, i) => {
        // ...
        slider.addEventListener('input', (e) => { 
            // Atualiza o peso do neurônio em TEMPO REAL com o valor do slider
            selectedNeuron.weights[i] = parseFloat(e.target.value); 
            simulateSingleNeuron(); // Recalcula a saída do neurônio imediatamente
            // ...
        });
    });
    // ... (código similar para o Bias)
}

Quando você arrasta um slider nesta visão, o código altera a propriedade selectedNeuron.weights e imediatamente recalcula a saída, criando uma conexão direta e intuitiva entre a causa (o valor do peso) e o efeito (a saída do neurônio).

5. Legenda de Termos (Glossário)

Para ajudar a desmistificar o jargão, aqui está uma tradução de alguns dos termos e metáforas usados nesta documentação.

“Culpa” / “Distribuindo a Culpa”

Backpropagation (Retropropagação do Erro)

Convergência

Delta

Feedforward (Avanço Direto)

Função de Ativação (Sigmoid)

Não-linear

Pesos (Weights)

Taxa de Aprendizado (Learning Rate)

Viés (Bias)

6. Referências

Voltar