npm - opencode-skills-collection - Versions diffs - 4.0.53 → 4.0.54 - Mend

opencode-skills-collection 4.0.53 → 4.0.54

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1168) hide show

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

@@ -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 CHANGED Viewed

@@ -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.