LABORATÓRIO INTERATIVO

Treine um perceptron ao vivo.

Escolha uma porta lógica, acompanhe cada atualização de peso e teste o resultado por conta própria.

Fronteira de decisão

Aguardando treino

Círculo: alvo 0 · quadrado: alvo 1 · linha: w₁x₁ + w₂x₂ + b = 0

O neurônio em ação

ŷ = —
Época0
Amostra—
Acertos—
Pesos—

Tabela-verdade e progresso

A linha destacada é o próximo exemplo de treinamento.

—
x₁x₂Alvo yPotencial uPrevisão ŷErroResultado

Erro × resposta

Cada ponto resume uma época completa da tabela-verdade.

Erro médioTaxa de acerto

Passo a passo matemático

Ainda não treinou
Clique em “Treinar 1 passo” para apresentar o primeiro exemplo ao perceptron.

Teste manual

Escolha uma entrada

Use este botão separadamente do treinamento: os pesos não são alterados.

CÓDIGO DIDÁTICO

Perceptron simples em JavaScript

Esta versão reduzida mantém cada responsabilidade em uma função. Leia na ordem: potencial → ativação → previsão → erro → ajuste.

dadoscalcularPotencial()degrau()prever()treinarAmostra()treinar()
perceptron-porta-logica.jsexemplo simplificado
// Dados supervisionados da porta AND.
// Cada item contém duas entradas e a resposta correta y.
const amostras = [
  { entradas: [0, 0], y: 0 },
  { entradas: [0, 1], y: 0 },
  { entradas: [1, 0], y: 0 },
  { entradas: [1, 1], y: 1 }
];

// A função degrau transforma o potencial u em uma decisão binária.
function degrau(u) {
  return u >= 0 ? 1 : 0;
}

// Calcula a combinação linear u = Σ(wᵢxᵢ) + b.
function calcularPotencial(entradas, pesos, bias) {
  return entradas.reduce(
    (soma, entrada, indice) => soma + entrada * pesos[indice],
    bias
  );
}

// Executa o forward pass e devolve a previsão ŷ.
function prever(entradas, modelo) {
  const u = calcularPotencial(entradas, modelo.pesos, modelo.bias);
  const yChapeu = degrau(u);
  return { u, yChapeu };
}

// Treina somente uma amostra e altera pesos e bias.
function treinarAmostra(amostra, modelo, taxaAprendizado) {
  const { yChapeu } = prever(amostra.entradas, modelo);
  const erro = amostra.y - yChapeu;

  // Cada peso recebe uma correção proporcional à sua entrada.
  modelo.pesos = modelo.pesos.map(
    (peso, indice) => peso + taxaAprendizado * erro * amostra.entradas[indice]
  );

  // O bias também aprende, mas não depende de uma entrada xᵢ.
  modelo.bias += taxaAprendizado * erro;
  return erro;
}

// Repete o treinamento por várias épocas.
function treinar(amostras, quantidadeEpocas, taxaAprendizado) {
  // O modelo começa com dois pesos e um bias pequenos.
  const modelo = { pesos: [0.1, -0.1], bias: 0 };

  Array.from({ length: quantidadeEpocas }).forEach(() => {
    amostras.forEach(amostra => {
      treinarAmostra(amostra, modelo, taxaAprendizado);
    });
  });

  return modelo;
}

// Treina e depois testa sem alterar os parâmetros.
const modeloTreinado = treinar(amostras, 20, 0.2);
amostras.forEach(amostra => {
  const resultado = prever(amostra.entradas, modeloTreinado);
  console.log(amostra.entradas, resultado.yChapeu);
});