LABORATÓRIO RBF 01 · CLASSIFICAÇÃO

Regiões curvas construídas por proximidade.

Seis neurônios Gaussianos medem a proximidade entre uma entrada 2D e centros de referência. A saída linear combina essas respostas e separa um grupo central de uma classe externa.

x₁, x₂entrada→φ₁ … φ₆distâncias→usaída linear→ŷStep(u−0,5)

Centros fixos

Escolhemos seis amostras representativas. Cada centro define uma região Gaussiana local.

c₁ … c₆

Ativações RBF

Entradas próximas de um centro produzem φ próximo de 1; entradas distantes produzem φ próximo de 0.

φⱼ(x)=e^{−γ‖x−cⱼ‖²}

Saída treinável

Apenas os pesos lineares e o bias são ajustados neste experimento.

u=b+Σwⱼφⱼ

ÉPOCAS0

MSE—

ACURÁCIA—

CENTROS6

Regiões de decisão não lineares

Os círculos maiores são centros. As linhas pontilhadas ligam a última amostra aos centros mais ativos.

Saída não treinada

classe A · centralclasse B · externacentro RBF

Rede e ativações da amostra

Os valores dentro da camada oculta são as respostas Gaussianas φ.

Último treinamento, passo a passo

Distâncias, Gaussianas, potencial u, erro e ajuste da saída.

Treine uma época para abrir as contas.

Erro × resposta

Compare a queda do MSE com o aumento da acurácia.

erroacurácia

Resultados do dataset

A saída contínua u é transformada em classe pelo limiar 0,5.

CÓDIGO COMPLETO E EXECUTÁVEL

Treine, avalie e use uma RBF classificadora

Os centros ficam fixos; o programa treina os pesos da saída, mede a acurácia e classifica uma nova entrada.

gaussiana()forward()treinar()avaliar()prever()

rbf-classificacao-completa.jsexecute do início ao fim

// 1. Cada centro representa uma região do plano.
var treino = [
  [0, 0, 0], [0.5, 0.2, 0], [-0.5, -0.4, 0], [0.2, -0.6, 0],
  [2.8, 0, 1], [-2.7, 0.5, 1], [0, -2.8, 1], [0, 2.7, 1]
];

var teste = [
  [0.3, 0.1, 0], [-0.4, 0.3, 0], [2.5, 0.4, 1], [-0.3, -2.6, 1]
];

var centros = [[0, 0], [0.8, 0.2], [-0.7, -0.3], [2.8, 0], [-2.7, 0.5], [0, -2.8]];
var pesosSaida = [0, 0, 0, 0, 0, 0];
var bias = 0;
var gamma = 0.85;

// 2. Calcula ‖x - c‖² sem usar objetos ou funções avançadas.
function distanciaQuadrada(x, centro) {
  var dx1 = x[0] - centro[0];
  var dx2 = x[1] - centro[1];
  return dx1 * dx1 + dx2 * dx2;
}

// 3. Transforma a distância em uma resposta local entre 0 e 1.
function gaussiana(x, centro) {
  return Math.exp(-gamma * distanciaQuadrada(x, centro));
}

// 4. Faz o forward e devolve [saída linear, ativações].
function forward(x) {
  var ativacoes = [];
  var u = bias;
  for (var j = 0; j < centros.length; j++) {
    ativacoes[j] = gaussiana(x, centros[j]);
    u = u + pesosSaida[j] * ativacoes[j];
  }
  return [u, ativacoes];
}

// 5. O treinamento usa a saída contínua u, antes do Step.
function calcularErro(y, u) {
  return y - u;
}

// 6. Ajusta cada peso de acordo com a ativação de sua Gaussiana.
function ajustarSaida(ativacoes, erro, taxa) {
  for (var j = 0; j < pesosSaida.length; j++) {
    pesosSaida[j] = pesosSaida[j] + taxa * erro * ativacoes[j];
  }
  bias = bias + taxa * erro;
}

// 7. Reúne o forward, o erro e o ajuste de uma amostra.
function treinarAmostra(x, y, taxa) {
  var resultado = forward(x);
  var u = resultado[0];
  var ativacoes = resultado[1];
  var erro = calcularErro(y, u);
  ajustarSaida(ativacoes, erro, taxa);
}

function treinar(dados, epocas, taxa) {
  for (var epoca = 0; epoca < epocas; epoca++) {
    for (var i = 0; i < dados.length; i++) {
      treinarAmostra([dados[i][0], dados[i][1]], dados[i][2], taxa);
    }
  }
}

// O limiar só é aplicado depois do treinamento da saída linear.
function prever(x) {
  if (forward(x)[0] >= 0.5) return 1;
  return 0;
}

function avaliar(dados) {
  var acertos = 0;
  for (var i = 0; i < dados.length; i++) {
    if (prever(dados[i]) === dados[i][2]) acertos++;
  }
  return acertos / dados.length;
}

// ----------------------- USO DO MODELO -----------------------
treinar(treino, 500, 0.04);
console.log('Acurácia de teste:', avaliar(teste));
console.log('Previsão para [2.6, 0.2]:', prever([2.6, 0.2]));