Muitas ADALINEs, mais de uma fronteira.

// Converte a entrada binária usada na interface para a notação bipolar.
function bipolar(valorBinario) {
  return valorBinario === 1 ? +1 : -1;
}

// Calcula a saída linear de uma unidade ADALINE.
function potencial(adaline, entradas) {
  return adaline.w1 * entradas[0]
       + adaline.w2 * entradas[1]
       + adaline.bias;
}

// O limitador transforma o potencial contínuo em uma decisão bipolar.
function sinal(u) {
  return u >= 0 ? +1 : -1;
}

// Cada ADALINE faz seu cálculo; a saída fixa executa uma lógica OR.
function forward(rede, entradas) {
  const ocultas = rede.map(adaline => {
    const u = potencial(adaline, entradas);
    return { u, z: sinal(u) };
  });
  const saida = ocultas.some(unidade => unidade.z === +1) ? +1 : -1;
  return { ocultas, saida };
}

// A MR-I altera somente as unidades necessárias para corrigir a resposta.
function selecionarUnidades(resultado, alvo) {
  if (resultado.saida === alvo) return [];

  // Para produzir +1, escolhe a unidade mais próxima do limiar.
  if (alvo === +1) {
    return [resultado.ocultas.reduce((melhor, atual, indice, lista) =>
      Math.abs(atual.u) < Math.abs(lista[melhor].u) ? indice : melhor, 0)];
  }

  // Para produzir -1, todas as unidades que votaram +1 devem ser corrigidas.
  return resultado.ocultas
    .map((unidade, indice) => unidade.z === +1 ? indice : -1)
    .filter(indice => indice >= 0);
}

// A Regra Delta/LMS usa o erro linear, calculado antes do limitador.
function atualizarLMS(adaline, entradas, respostaDesejada, eta) {
  const u = potencial(adaline, entradas);
  const erroLinear = respostaDesejada - u;
  adaline.w1 += eta * erroLinear * entradas[0];
  adaline.w2 += eta * erroLinear * entradas[1];
  adaline.bias += eta * erroLinear;
}

// Um passo completo: forward, responsabilidade e atualização das escolhidas.
function treinarAmostra(rede, entradas, alvo, eta) {
  const resultado = forward(rede, entradas);
  const escolhidas = selecionarUnidades(resultado, alvo);
  escolhidas.forEach(indice =>
    atualizarLMS(rede[indice], entradas, alvo, eta)
  );
}

// Tabela XOR em notação bipolar: -1 representa 0 e +1 representa 1.
const dados = [
  { entradas: [-1, -1], alvo: -1 },
  { entradas: [-1, +1], alvo: +1 },
  { entradas: [+1, -1], alvo: +1 },
  { entradas: [+1, +1], alvo: -1 }
];

// Duas ADALINEs formam a camada oculta da MADALINE.
const rede = [
  { w1: 0, w2: 0, bias: 0 },
  { w1: 0, w2: 0, bias: 0 }
];

function treinar(rede, dados, maximoEpocas, taxa) {
  for (let epoca = 1; epoca <= maximoEpocas; epoca++) {
    let erros = 0;

    for (let i = 0; i < dados.length; i++) {
      const antes = forward(rede, dados[i].entradas).saida;
      if (antes !== dados[i].alvo) erros++;
      treinarAmostra(rede, dados[i].entradas, dados[i].alvo, taxa);
    }
    if (erros === 0) return epoca;
  }
  return maximoEpocas;
}

function avaliar(rede, dados) {
  let acertos = 0;
  for (let i = 0; i < dados.length; i++) {
    if (forward(rede, dados[i].entradas).saida === dados[i].alvo) acertos++;
  }
  return acertos / dados.length;
}

function preverBinario(rede, x1, x2) {
  const entradas = [bipolar(x1), bipolar(x2)];
  return forward(rede, entradas).saida === +1 ? 1 : 0;
}

// ----------------------- USO DO MODELO -----------------------
const epocas = treinar(rede, dados, 500, 0.08);
console.log('Épocas:', epocas);
console.log('Acurácia:', avaliar(rede, dados));
console.log('XOR(1, 0):', preverBinario(rede, 1, 0));
console.log('Pesos aprendidos:', rede);