Exemplo de uso:

cd single-layer-perceptron/backend
./run.sh

Aprendizado:

• Convergência garantida para problemas linearmente separáveis
• Codificação binária criativa para múltiplas classes
• Base histórica das redes neurais

Fase 2: Multi-Layer Perceptron (1986)

Baseado em Rumelhart, Hinton e Williams

multi-layer-network/

O que foi implementado:

• ✅ Múltiplas camadas (entrada → ocultas → saída)
• ✅ Função de ativação Sigmoid (diferenciável)
• ✅ Backpropagation completo
• ✅ Mini-batch gradient descent
• ✅ Xavier/Glorot initialization
• ✅ Gradient clipping
• ✅ Early stopping
• ✅ Cross-entropy loss

Arquitetura:

# Exemplo: 256 → 64 → 32 → 2
MLP(layer_sizes=[256, 64, 32, 2], learning_rate=0.3)

Melhorias sobre Single-Layer:

• ✅ Aprende padrões não-lineares (XOR, círculos, etc)
• ✅ Representações hierárquicas
• ✅ Convergência mais robusta
• ✅ Generalização melhorada

Dataset Balanceado:

• 442 exemplos de "T" (3 variações de tamanho)
• 442 exemplos de "No-T" (8 letras + formas aleatórias)
• 882 amostras totais (50/50 balanceado)

Técnicas de Data Augmentation:

# Gera variações deslocando padrão pixel-by-pixel
# T de 5×5 → 144 posições (12×12 grid)
# T de 3×3 → 196 posições (14×14 grid)
# T de 7×7 → 100 posições (10×10 grid)

Fase 3: Multi-Layer with Human-in-the-Loop (2023+)

Baseado em RLHF (ChatGPT) e Active Learning

multi-layer-network-with-human-enforcement/

O que foi implementado:

1️⃣ Active Learning

Sistema pede feedback quando incerto (entropia > 30%)

def predict_with_uncertainty(self, X):
    # Calcula entropia da distribuição de probabilidades
    entropy = -Σ(p * log(p))
    uncertainty = entropy / max_entropy

    if uncertainty > threshold:
        return "PEDIR FEEDBACK HUMANO"

Quando pedir feedback:

• 🟢 < 20% incerteza: Modelo confiante
• 🟠 20-40%: Incerteza média
• 🔴 > 40%: Pedir feedback!

2️⃣ RLHF (Reinforcement Learning from Human Feedback)

Ajusta pesos instantaneamente com correção humana

def learn_from_feedback(self, X, correct_label):
    # 1. Forward propagation
    prediction = self.predict(X)

    # 2. Backpropagation com label correto
    gradients = self.backprop(X, correct_label)

    # 3. Update com learning rate MAIOR (0.5)
    self.weights -= 0.5 * gradients

    # 4. Salvar modelo atualizado
    self.save_model()

Diferença do treinamento normal:

• LR maior (0.5 vs 0.1-0.3)
• Update imediato (não espera epoch)
• Salva modelo após cada feedback

3️⃣ Feedback Tracking

Sistema monitora evolução com feedback humano

# Estatísticas armazenadas
{
    'total_feedback': 45,
    'improvements': 38,
    'improvement_rate': 0.844,  # 84.4% das correções melhoraram
    'feedback_by_label': {
        'T': 22,
        'No-T': 23
    }
}

Interface Visual:

• 📊 Barra de incerteza colorida
• 🎯 Active Learning alerts
• 📈 Gráfico de probabilidades
• ✏️ Formulário de correção
• 📉 Estatísticas em tempo real

🏗️ Arquitetura

Stack Tecnológico

Backend:

Python 3.12
├── FastAPI (API REST)
├── NumPy (Computação numérica)
├── SQLite (Persistência)
└── Uvicorn (Servidor ASGI)

Frontend:

React 18 + TypeScript
├── Vite (Build tool)
├── TanStack Router (Roteamento)
└── CSS Modules (Estilização)

Estrutura de Diretórios

perceptrons/
│
├── single-layer-perceptron/
│   ├── backend/
│   │   ├── perceptron.py          # Perceptron simples
│   │   ├── multi_perceptron.py    # Codificação binária
│   │   ├── main.py                # API FastAPI
│   │   └── patterns.db            # Dataset
│   └── frontend/
│       └── src/
│           ├── pages/
│           │   ├── Dataset.tsx    # Criar padrões
│           │   ├── Training.tsx   # Treinar modelo
│           │   └── Test.tsx       # Testar modelo
│           └── App.tsx
│
├── multi-layer-network/
│   ├── backend/
│   │   ├── mlp.py                 # MLP com backprop
│   │   ├── main.py                # API REST
│   │   ├── patterns.db            # Dataset balanceado (882)
│   │   ├── generate_variations.py # Data augmentation
│   │   ├── build_balanced_dataset.py
│   │   └── models/                # Modelos treinados
│   └── frontend/
│       └── src/
│           └── pages/
│               ├── Training.tsx   # Config hiperparâmetros
│               └── Test.tsx
│
└── multi-layer-network-with-human-enforcement/
    ├── backend/
    │   ├── mlp.py                 # MLP base
    │   ├── mlp_hitl.py            # MLP + HITL ⭐
    │   ├── main.py                # API com endpoints HITL
    │   └── patterns.db            # Dataset + feedback
    └── frontend/
        └── src/
            └── pages/
                └── TestHITL.tsx   # Interface HITL ⭐

💻 Instalação

Pré-requisitos

# Python 3.12+
python3 --version

# Node.js 18+
node --version

Setup Rápido

1. Clone o repositório:

git clone https://github.com/seu-usuario/perceptrons.git
cd perceptrons

2. Escolha qual versão rodar:

Opção A: Single-Layer Perceptron

# Backend
cd single-layer-perceptron/backend
python3 -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt
./run.sh  # ou: uvicorn main:app --reload

# Frontend (novo terminal)
cd ../frontend
npm install
npm run dev

Opção B: Multi-Layer Perceptron

# Backend
cd multi-layer-network/backend
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
./run.sh

# Frontend
cd ../frontend
npm install
npm run dev

Opção C: MLP with HITL ⭐

# Backend
cd multi-layer-network-with-human-enforcement/backend
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
./run.sh

# Frontend
cd ../frontend
npm install
npm run dev

3. Acesse:

• Frontend: http://localhost:5173
• API: http://localhost:8000
• Docs: http://localhost:8000/docs

🎮 Como Usar

1. Single-Layer Perceptron

Passo a passo:

1. Dataset (/dataset)

   • Desenhe padrões 16×16
   • Rotule como "T" ou outra letra
   • Salve múltiplos exemplos

2. Training (/training)

   • Escolha número de neurônios (1-4)
   • Configure épocas (padrão: 100)
   • Inicie treinamento
   • Veja codificação binária gerada

3. Test (/test)

   • Selecione modelo treinado
   • Desenhe padrão
   • Veja predição + código binário

2. Multi-Layer Perceptron

Dataset Balanceado (já incluído):

• ✅ 442 exemplos de "T"
• ✅ 442 exemplos de "No-T"
• ✅ Variações automáticas (data augmentation)

Treinamento:

# Hiperparâmetros recomendados
{
    "hidden_layers": [64, 32],      # 256→64→32→2
    "learning_rate": 0.3,            # LR alto converge rápido
    "batch_size": 16,                # Mini-batch
    "epochs": 300                    # Early stopping ativo
}

Resultados esperados:

• Acurácia: 95-100%
• Convergência: ~100-200 épocas
• Loss final: < 0.05

3. MLP with Human-in-the-Loop

Workflow:

1. Treinar modelo base (/training)

   • Use dataset balanceado
   • Configure arquitetura (ex: 64,32)
   • Treine até ~95% acurácia

2. Testar com HITL (/test-hitl)

   • Desenhe padrão
   • Sistema mostra:
     • Predição
     • Incerteza (%)
     • Probabilidades por classe
     • Alert se incerto

3. Fornecer Feedback

   • Se predição errada → Corrigir
   • Sistema aplica RLHF imediatamente
   • Modelo salvo automaticamente
   • Veja estatísticas atualizadas

Métricas HITL:

{
  "total_feedback": 50,
  "improvements": 42,
  "improvement_rate": 0.84,  // 84% melhoraram
  "feedback_by_label": {
    "T": 25,
    "No-T": 25
  }
}

📖 Conceitos Implementados

Algoritmos

1. Perceptron Learning Rule (1957)

# Para cada exemplo (x, y):
prediction = sign(w·x + b)
if prediction != y:
    w = w + η * y * x
    b = b + η * y

2. Backpropagation (1986)

# Forward pass
for layer in layers:
    z = W @ a + b
    a = sigmoid(z)

# Backward pass
δ_L = (a_L - y) ⊙ σ'(z_L)
for layer in reversed(layers):
    ∇W = a^T @ δ / m
    ∇b = sum(δ) / m
    δ = (δ @ W^T) ⊙ σ'(a)

# Update
W = W - η * ∇W
b = b - η * ∇b

3. Active Learning (2000s)

# Entropy-based uncertainty
H(p) = -Σ p_i * log(p_i)
uncertainty = H(p) / log(K)  # Normalizado

if uncertainty > threshold:
    request_human_feedback()

4. RLHF (2020s)

# Recebe correção humana
correct_label = human_input()

# Backprop com label correto
loss = cross_entropy(prediction, correct_label)
gradients = backward(loss)

# Update com LR maior
weights -= 0.5 * gradients  # vs 0.1 normal
save_model()

Técnicas de Otimização

Data Augmentation

# Gera variações deslocando padrão
def generate_variations(pattern):
    for row in range(max_positions_y):
        for col in range(max_positions_x):
            if (row, col) != original_position:
                yield shift_pattern(pattern, row, col)

# Exemplo: T de 5×5
# Grid 16×16 permite posições: (16-5+1) × (16-5+1) = 12×12 = 144
# Menos posição original = 143 variações

📊 Resultados

Single-Layer Perceptron

Problema: Classificar "T" vs "No-T"

Conclusão: Insuficiente para padrões complexos.

Multi-Layer Perceptron

Mesmo problema com dataset balanceado