opencode-skills-collection 4.0.53 → 4.0.55

package/bundled-skills/yann-lecun-filosofia/SKILL.md

@@ -413,6 +413,12 @@ Quando este skill é carregado junto com yann-lecun principal:
 - `yann-lecun-debate` - Complementary skill for enhanced analysis
 - `yann-lecun-tecnico` - Complementary skill for enhanced analysis
 
+## Example
+
+**User request:**
+
+> Use @yann-lecun-filosofia for this task: Sub-skill filosófica e pedagógica de Yann LeCun.
+
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

package/bundled-skills/yann-lecun-tecnico/SKILL.md

@@ -21,9 +21,9 @@ tools:
 
 # YANN LECUN — MÓDULO TÉCNICO v3.0
 
-## Overview
+## Detailed Guide
 
-Sub-skill técnica de Yann LeCun. Cobre CNNs, LeNet, backpropagation, JEPA (I-JEPA, V-JEPA, MC-JEPA), AMI (Advanced Machinery of Intelligence), Self-Supervised Learning (SimCLR, MAE, BYOL), Energy-Based Models (EBMs) e código PyTorch completo.
+Read [the detailed guide](references/detailed-guide.md) before executing this skill. It retains the complete procedure and reference material. Treat its safety, prerequisites, and validation requirements as mandatory. For focused work, load the relevant sections; for end-to-end work, read the guide completely.
 
 ## When to Use This Skill
 
@@ -35,489 +35,6 @@ Sub-skill técnica de Yann LeCun. Cobre CNNs, LeNet, backpropagation, JEPA (I-JE
 - A simpler, more specific tool can handle the request
 - The user needs general-purpose assistance without domain expertise
 
-## How It Works
-
-> Este módulo é carregado pelo agente yann-lecun principal quando a conversa
-> exige profundidade técnica. Você continua sendo LeCun — apenas com acesso
-> a todo o arsenal técnico.
-
----
-
-## Convolutional Neural Networks: Do Princípio
-
-A operação de convolução 2D discreta:
-
-```
-Saida[i][j] = sum_{m} sum_{n} Input[i+m][j+n] * Kernel[m][n]
-```
-
-O insight arquitetural **triplo** das CNNs:
-
-**1. Local Connectivity**
-```
-
-## Antes (Fully Connected): Neurônio I -> Todos Os Pixels
-
-params = input_size * hidden_size  # enorme
-
-## Cnns: Neurônio -> Região Local [K X K]
-
-params = kernel_h * kernel_w * in_channels * out_channels
-
-## Fisicamente Motivado: Features Visuais São Locais
-
-```
-
-**2. Weight Sharing**
-```
-
-## Resultado: Translation Equivariance
-
-for i in range(output_height):
-    for j in range(output_width):
-        output[i][j] = conv2d(input[i:i+k, j:j+k], shared_kernel)
-```
-
-**3. Hierarquia de Representações**
-```
-
-## Total: ~60,000 Parâmetros
-
-```
-
-O insight central: **features não precisam ser handcrafted**. Aprendem por gradiente.
-Em 2012, AlexNet provou. Eu dizia isso desde 1989.
-
-## Backpropagation: A Equação Central
-
-```
-delta_L = dL/da_L  (gradiente na camada de saída)
-delta_l = (W_{l+1}^T * delta_{l+1}) * f'(z_l)
-dL/dW_l = delta_l * a_{l-1}^T
-dL/db_l = delta_l
-```
-
-Backprop não é algoritmo milagroso. É chain rule aplicada a funções compostas.
-Implementável eficientemente em GPUs por ser sequência de multiplicações de matrizes.
-
-## Self-Supervised Learning: Objetivos E Formalização
-
-**Variante generativa (MAE, BERT)**:
-```
-L_gen = E[||f_theta(x_masked) - x_target||^2]
-
-## Para Imagens: Cada Pixel. Desperdiçador De Capacidade.
-
-```
-
-**Variante contrastiva (SimCLR, MoCo)**:
-```
-L_contrastive = -log( exp(sim(z_i, z_j) / tau) /
-                      sum_k exp(sim(z_i, z_k) / tau) )
-
-## Tau: Temperature Hyperparameter
-
-```
-
-Problema das contrastivas: precisam de "negatives" — batch grande. Motivou BYOL e JEPA.
-
----
-
-## Formulação Central
-
-JEPA: **prever em espaço de representações, não em espaço de inputs**.
-
-```
-
-## Dois Encoders (Ou Um Com Stop-Gradient):
-
-s_x = f_theta(x)           # contexto encoder
-s_y = f_theta_bar(y)       # target encoder (momentum de theta)
-
-## Predictor:
-
-s_hat_y = g_phi(s_x)       # prevê representação de y dado x
-
-## Objetivo:
-
-L_JEPA = ||s_y - s_hat_y||^2    # MSE no espaço de representações
-
-## Prevenção De Colapso: Target Encoder Usa Momentum (Ema)
-
-theta_bar <- m * theta_bar + (1-m) * theta   # m ~ 0.996
-```
-
-**Por que JEPA supera geração de pixels/tokens**:
-
-| Abordagem | Prevê | Capacidade gasta em | Semântica |
-|-----------|-------|---------------------|-----------|
-| MAE | Pixels exatos | Texturas, ruídos, irrelevantes | Custosamente |
-| BERT | Tokens exatos | Detalhes lexicais | Custosamente |
-| Contrastiva | Invariâncias | Negativos (batch grande) | Sim |
-| **JEPA** | **Representação abstrata** | **Relações semânticas** | **Eficientemente** |
-
-## I-Jepa: Pseudocódigo Pytorch Completo
-
-```python
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import copy
-
-class IJEPA(nn.Module):
-    """
-    I-JEPA: Image Joint Embedding Predictive Architecture
-    Assran et al. 2023 — CVPR
-    """
-    def __init__(self, encoder, predictor, momentum=0.996):
-        super().__init__()
-        self.context_encoder = encoder
-        self.target_encoder = copy.deepcopy(encoder)
-        self.predictor = predictor
-        self.momentum = momentum
-
-        for param in self.target_encoder.parameters():
-            param.requires_grad = False
-
-    @torch.no_grad()
-    def update_target_encoder(self):
-        """EMA update"""
-        for param_ctx, param_tgt in zip(
-            self.context_encoder.parameters(),
-            self.target_encoder.parameters()
-        ):
-            param_tgt.data = (
-                self.momentum * param_tgt.data +
-                (1 - self.momentum) * param_ctx.data
-            )
-
-    def forward(self, images):
-        context_patches, target_patches, masks = self.create_masks(images)
-        context_embeds = self.context_encoder(context_patches, masks)
-
-        with torch.no_grad():
-            target_embeds = self.target_encoder(target_patches)
-
-        predicted_embeds = self.predictor(context_embeds, target_positions)
-        loss = F.mse_loss(predicted_embeds, target_embeds.detach())
-        return loss
-
-    def create_masks(self, images, num_target_blocks=4, context_scale=0.85):
-        """
-        Estratégia I-JEPA:
-        - Múltiplos blocos alvo aleatórios (alto aspect ratio)
-        - Contexto: imagem com blocos alvo mascarados
-        """
-        B, C, H, W = images.shape
-        patch_size = 16
-        n_patches_h = H // patch_size
-        n_patches_w = W // patch_size
-
-        target_masks = generate_random_blocks(
-            n_patches_h, n_patches_w,
-            num_blocks=num_target_blocks,
-            scale_range=(0.15, 0.2),
-            aspect_ratio_range=(0.75, 1.5)
-        )
-        context_mask = ~targe
-
-## V-Jepa: Extensão Temporal
-
-```python
-
-## Prever Representação De Frames Futuros Em Posições Mascaradas
-
-L_V_JEPA = E[||f_target(video_masked) - g(f_ctx(video_ctx), positions)||^2]
-
-## Sem Nenhum Label.
-
-```
-
-## Hierarquia De Encoders
-
-Level 0: pixels -> patches -> representações locais (bordas, texturas)
-Level 1: patches -> regiões -> representações de objetos
-Level 2: regiões -> cena -> representações de relações espaciais
-Level 3: cena -> temporal -> representações de eventos
-
-## Cada Nível Tem Seu Próprio Jepa:
-
-L_total = sum_l lambda_l * L_JEPA_l
-
-## Resultado: World Model Hierárquico Multi-Escala
-
-```
-
----
-
-## Seção Ami — Advanced Machinery Of Intelligence
-
-Paper: "A Path Towards Autonomous Machine Intelligence" (2022)
-
-## Os 6 Módulos Do Ami
-
-```
-+----------------------------------------------------------+
-|                 SISTEMA AMI COMPLETO                      |
-|                                                          |
-|  +-----------+    +------------------+                  |
-|  | Perceptor |    | World Model      |                  |
-|  | (encoders)|    | (JEPA hierárquico)|                 |
-|  +-----------+    +------------------+                  |
-|        |                  |                             |
-|        v                  v                             |
-|  +----------+    +------------------+                   |
-|  | Memory   |<-->| Cost Module      |                   |
-|  | (epis,   |    | (intrínseco +    |                   |
-|  |  semant) |    |  configurável)   |                   |
-|  +----------+    +------------------+                   |
-|                           |                             |
-|                  +------------------+                   |
-|                  | Actor (planner   |                   |
-|                  | + executor)      |                   |
-|                  +------------------+                   |
-+----------------------------------------------------------+
-```
-
-**Módulo 1 — Configurator**: Configura os outros módulos para a tarefa atual.
-
-**Módulo 2 — Perception**: Encoders sensório-motores que alimentam o world model.
-
-**Módulo 3 — World Model** (coração do sistema):
-```
-
-## Simulação Interna: "O Que Acontece Se Eu Fizer X?"
-
-predicted_next_state = world_model(current_state, action_X)
-cost_predicted = cost_module(predicted_next_state)
-
-## Escolhe Ação Que Minimiza O Custo
-
-```
-
-**Módulo 4 — Cost Module**:
-```
-
-## Dois Tipos De Custo:
-
-E(s) = alpha * intrinsic_cost(s) + beta * task_cost(s)
-
-## Task_Cost: Objetivo Configurável Por Tarefa/Humano
-
-```
-
-**Módulo 5 — Short-term Memory**: Buffer de estados, simulações, contexto imediato.
-
-**Módulo 6 — Actor**:
-- Modo reativo: ações diretas do estado atual
-- Modo deliberativo: simula múltiplos futuros, escolhe mínimo custo
-
-## Ami Vs Llms
-
-| Feature | LLM | AMI |
-|---------|-----|-----|
-| Objetivo | Prever próximo token | Minimizar erro em representação |
-| World model | Nenhum | Módulo dedicado central |
-| Planning | Texto sobre planning | Planning real com simulação |
-| Memória | Context window (fixo) | Memória episódica atualizável |
-| Objetivos | Apenas treinamento | Cost module configurável |
-| Input | Texto | Multi-modal (video, audio, propriocepção) |
-| Causalidade | Correlacional | Causal (dinâmicas do mundo) |
-
----
-
-## Seção Ebm — Energy-Based Models
-
-Contribuição subestimada que vai ser mais influente a longo prazo.
-
-**O problema com probabilísticos**:
-```
-P(x) = exp(-E(x)) / Z
-Z = integral exp(-E(x)) dx   # intratável em alta dimensão!
-```
-
-**A solução EBM**: esquecer Z. Defina E(x) onde:
-- Baixa energia = configuração compatível com dados observados
-- Alta energia = configuração incompatível
-
-```python
-class EnergyBasedModel(nn.Module):
-    """
-    EBM: F(x) = energia de x
-    P(x) ~ exp(-F(x)) / Z  — mas nunca calculamos Z!
-    Vantagem: sem partition function intratável.
-    """
-    def __init__(self, latent_dim=512):
-        super().__init__()
-        self.energy_net = nn.Sequential(
-            nn.Linear(latent_dim, 256),
-            nn.SiLU(),
-            nn.Linear(256, 128),
-            nn.SiLU(),
-            nn.Linear(128, 1)  # escalar: energia
-        )
-
-    def energy(self, x):
-        return self.energy_net(x).squeeze(-1)
-
-    def contrastive_loss(self, x_pos, x_neg):
-        """
-        L = E[F(x_pos)] - E[F(x_neg)] + regularização
-        Queremos: E_pos < E_neg
-        """
-        E_pos = self.energy(x_pos)
-        E_neg = self.energy(x_neg)
-        loss = E_pos.mean() - E_neg.mean()
-        reg = 0.1 * (E_pos.pow(2).mean() + E_neg.pow(2).mean())
-        return loss + reg
-
-## Ebms Capturam Isso Naturalmente — São Sobre Compatibilidade, Não Probabilidade."
-
-```
-
-**JEPA como EBM no espaço de representações**:
-```
-E(x, y) = ||f_theta(x) - g_phi(f_theta_bar(y))||^2
-
-## Simclr Simplificado
-
-```python
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision.transforms as T
-
-
-class ProjectionHead(nn.Module):
-    """MLP que projeta representações para espaço contrastivo"""
-    def __init__(self, in_dim=512, hidden_dim=256, out_dim=128):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(in_dim, hidden_dim),
-            nn.BatchNorm1d(hidden_dim),
-            nn.ReLU(inplace=True),
-            nn.Linear(hidden_dim, out_dim)
-        )
-
-    def forward(self, x):
-        return F.normalize(self.net(x), dim=-1)
-
-
-class SimCLRLoss(nn.Module):
-    """NT-Xent Loss (Chen et al. 2020)"""
-    def __init__(self, temperature=0.5):
-        super().__init__()
-        self.temp = temperature
-
-    def forward(self, z1, z2):
-        """
-        z1, z2: [B, D] — duas views do mesmo batch
-        z1[i] e z2[i]: positive pair
-        Todos outros pares: negatives
-        """
-        B = z1.size(0)
-        z = torch.cat([z1, z2], dim=0)
-        sim = torch.mm(z, z.t()) / self.temp
-        mask = torch.eye(2*B, device=z.device).bool()
-        sim.masked_fill_(mask, float('-inf'))
-        labels = torch.arange(B, device=z.device)
-        labels = torch.cat([labels + B, labels])
-        return F.cross_entropy(sim, labels)
-
-
-def get_ssl_augmentations(size=224):
-    """
-    As augmentações DEFINEM o que o modelo aprende a ser invariante.
-    Rotação -> invariância a rotação.
-    Crop -> invariância a posição.
-    """
-    return T.Compose([
-        T.RandomResizedCrop(size, scale=(0.2, 1.0)),
-        T.RandomHorizontalFlip(),
-        T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1),
-        T.RandomGrayscale(p=0.2),
-        T.GaussianBlur(kernel_size=size//10*2+1, sigma=(0.1, 2.0)),
-        T.ToTensor(),
-        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-    ])
-```
-
-## Lenet-5 Original Em Pytorch Moderno
-
-```python
-class LeNet5Modern(nn.Module):
-    """
-    LeNet-5 (LeCun et al. 1998) reimplementada em PyTorch moderno.
-    Esta arquitetura rodou em produção no Bank of America em 1993.
-    ~60,000 parâmetros. Mesmos princípios de modelos modernos com bilhões.
-    """
-    def __init__(self, num_classes=10):
-        super().__init__()
-        self.features = nn.Sequential(
-            nn.Conv2d(1, 6, kernel_size=5, padding=2),
-            nn.Tanh(),
-            nn.AvgPool2d(kernel_size=2, stride=2),
-            nn.Conv2d(6, 16, kernel_size=5),
-            nn.Tanh(),
-            nn.AvgPool2d(kernel_size=2, stride=2),
-            nn.Conv2d(16, 120, kernel_size=5),
-            nn.Tanh(),
-        )
-        self.classifier = nn.Sequential(
-            nn.Linear(120, 84),
-            nn.Tanh(),
-            nn.Linear(84, num_classes),
-        )
-
-    def forward(self, x):
-        x = self.features(x)    # [B, 120, 1, 1]
-        x = x.view(x.size(0), -1)
-        return self.classifier(x)
-```
-
----
-
-## Papers Fundamentais (Lecun)
-
-- LeCun et al. (1998). "Gradient-Based Learning Applied to Document Recognition" — IEEE 86(11)
-- LeCun et al. (2015). "Deep Learning" — Nature 521:436-444
-- LeCun (2022). "A Path Towards Autonomous Machine Intelligence" — OpenReview preprint
-
-## Jepa Papers
-
-- Assran et al. (2023). "Self-Supervised Learning from Images with a JEPA" — CVPR 2023 (I-JEPA)
-- Bardes et al. (2024). "V-JEPA: Self-Supervised Learning of Video Representations" — NeurIPS 2023
-- LeCun (2016). "Predictive Learning" — NIPS Keynote (The Cake Analogy)
-
-## Ssl Relevantes
-
-- He et al. (2022). "Masked Autoencoders Are Scalable Vision Learners" — CVPR 2022
-- Chen et al. (2020). "A Simple Framework for Contrastive Learning" (SimCLR) — ICML 2020
-- Grill et al. (2020). "Bootstrap Your Own Latent" (BYOL) — NeurIPS 2020
-
-## Energy-Based Models
-
-- LeCun et al. (2006). "A Tutorial on Energy-Based Learning" — ICLR Workshop
-- LeCun (2021). "Energy-Based Models for Autonomous and Predictive Learning" — ICLR Keynote
-
-## Best Practices
-
-- Provide clear, specific context about your project and requirements
-- Review all suggestions before applying them to production code
-- Combine with other complementary skills for comprehensive analysis
-
-## Common Pitfalls
-
-- Using this skill for tasks outside its domain expertise
-- Applying recommendations without understanding your specific context
-- Not providing enough project context for accurate analysis
-
-## Related Skills
-
-- `yann-lecun` - Complementary skill for enhanced analysis
-- `yann-lecun-debate` - Complementary skill for enhanced analysis
-- `yann-lecun-filosofia` - Complementary skill for enhanced analysis
-
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.