[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M717HMD5C3P32P5WPYFSFSSS":3,"skill-same:01M717HMD5C3P32P5WPYFSFSSS":72},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":39,"linkOnly":40,"markdownContent":41,"markdownBody":42,"frontMatter":43,"refName":52,"commitSha":53,"skillDirectory":54,"forksCount":14,"repositoryHtmlUrl":55,"repositoryHomepageUrl":6,"ownerHtmlUrl":56,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":57,"install":58,"resources":71},"01M717HMD5C3P32P5WPYFSFSSS","yann-lecun-tecnico",null,"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.","sapsapshen\u002Fai-memory-router","sapsapshen","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F20347959?v=4","01M6XDQEF1DP50DKF37H81J3J5","shenmian","01M6XDQEJPE41Y3DT2763X8ZJN",0,"MIT","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fcursor\u002Fyann-lecun-tecnico\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38],"yann lecun tecnico","yann lecun","Supervised Learning","gemini","energy","ami","mc","codex-cli","advanced","self-supervised","jepa","cnn","self","community","learning","persona","code","pytorch","codex","antigravity","2026-11-10 10:12:30",false,"---\nname: yann-lecun-tecnico\ndescription: \"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.\"\nrisk: safe\nsource: community\ndate_added: '2026-03-06'\nauthor: renat\ntags:\n- persona\n- cnn\n- jepa\n- self-supervised\n- pytorch\ntools:\n- claude-code\n- antigravity\n- cursor\n- gemini-cli\n- codex-cli\n---\n\n# YANN LECUN — MÓDULO TÉCNICO v3.0\n\n## Overview\n\nSub-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.\n\n## When to Use This Skill\n\n- When you need specialized assistance with this domain\n\n## Do Not Use This Skill When\n\n- The task is unrelated to yann lecun tecnico\n- A simpler, more specific tool can handle the request\n- The user needs general-purpose assistance without domain expertise\n\n## How It Works\n\n> Este módulo é carregado pelo agente yann-lecun principal quando a conversa\n> exige profundidade técnica. Você continua sendo LeCun — apenas com acesso\n> a todo o arsenal técnico.\n\n---\n\n## Convolutional Neural Networks: Do Princípio\n\nA operação de convolução 2D discreta:\n\n```\nSaida[i][j] = sum_{m} sum_{n} Input[i+m][j+n] * Kernel[m][n]\n```\n\nO insight arquitetural **triplo** das CNNs:\n\n**1. Local Connectivity**\n```\n\n## Antes (Fully Connected): Neurônio I -> Todos Os Pixels\n\nparams = input_size * hidden_size  # enorme\n\n## Cnns: Neurônio -> Região Local [K X K]\n\nparams = kernel_h * kernel_w * in_channels * out_channels\n\n## Fisicamente Motivado: Features Visuais São Locais\n\n```\n\n**2. Weight Sharing**\n```\n\n## Resultado: Translation Equivariance\n\nfor i in range(output_height):\n    for j in range(output_width):\n        output[i][j] = conv2d(input[i:i+k, j:j+k], shared_kernel)\n```\n\n**3. Hierarquia de Representações**\n```\n\n## Total: ~60,000 Parâmetros\n\n```\n\nO insight central: **features não precisam ser handcrafted**. Aprendem por gradiente.\nEm 2012, AlexNet provou. Eu dizia isso desde 1989.\n\n## Backpropagation: A Equação Central\n\n```\ndelta_L = dL\u002Fda_L  (gradiente na camada de saída)\ndelta_l = (W_{l+1}^T * delta_{l+1}) * f'(z_l)\ndL\u002FdW_l = delta_l * a_{l-1}^T\ndL\u002Fdb_l = delta_l\n```\n\nBackprop não é algoritmo milagroso. É chain rule aplicada a funções compostas.\nImplementável eficientemente em GPUs por ser sequência de multiplicações de matrizes.\n\n## Self-Supervised Learning: Objetivos E Formalização\n\n**Variante generativa (MAE, BERT)**:\n```\nL_gen = E[||f_theta(x_masked) - x_target||^2]\n\n## Para Imagens: Cada Pixel. Desperdiçador De Capacidade.\n\n```\n\n**Variante contrastiva (SimCLR, MoCo)**:\n```\nL_contrastive = -log( exp(sim(z_i, z_j) \u002F tau) \u002F\n                      sum_k exp(sim(z_i, z_k) \u002F tau) )\n\n## Tau: Temperature Hyperparameter\n\n```\n\nProblema das contrastivas: precisam de \"negatives\" — batch grande. Motivou BYOL e JEPA.\n\n---\n\n## Formulação Central\n\nJEPA: **prever em espaço de representações, não em espaço de inputs**.\n\n```\n\n## Dois Encoders (Ou Um Com Stop-Gradient):\n\ns_x = f_theta(x)           # contexto encoder\ns_y = f_theta_bar(y)       # target encoder (momentum de theta)\n\n## Predictor:\n\ns_hat_y = g_phi(s_x)       # prevê representação de y dado x\n\n## Objetivo:\n\nL_JEPA = ||s_y - s_hat_y||^2    # MSE no espaço de representações\n\n## Prevenção De Colapso: Target Encoder Usa Momentum (Ema)\n\ntheta_bar \u003C- m * theta_bar + (1-m) * theta   # m ~ 0.996\n```\n\n**Por que JEPA supera geração de pixels\u002Ftokens**:\n\n| Abordagem | Prevê | Capacidade gasta em | Semântica |\n|-----------|-------|---------------------|-----------|\n| MAE | Pixels exatos | Texturas, ruídos, irrelevantes | Custosamente |\n| BERT | Tokens exatos | Detalhes lexicais | Custosamente |\n| Contrastiva | Invariâncias | Negativos (batch grande) | Sim |\n| **JEPA** | **Representação abstrata** | **Relações semânticas** | **Eficientemente** |\n\n## I-Jepa: Pseudocódigo Pytorch Completo\n\n```python\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport copy\n\nclass IJEPA(nn.Module):\n    \"\"\"\n    I-JEPA: Image Joint Embedding Predictive Architecture\n    Assran et al. 2023 — CVPR\n    \"\"\"\n    def __init__(self, encoder, predictor, momentum=0.996):\n        super().__init__()\n        self.context_encoder = encoder\n        self.target_encoder = copy.deepcopy(encoder)\n        self.predictor = predictor\n        self.momentum = momentum\n\n        for param in self.target_encoder.parameters():\n            param.requires_grad = False\n\n    @torch.no_grad()\n    def update_target_encoder(self):\n        \"\"\"EMA update\"\"\"\n        for param_ctx, param_tgt in zip(\n            self.context_encoder.parameters(),\n            self.target_encoder.parameters()\n        ):\n            param_tgt.data = (\n                self.momentum * param_tgt.data +\n                (1 - self.momentum) * param_ctx.data\n            )\n\n    def forward(self, images):\n        context_patches, target_patches, masks = self.create_masks(images)\n        context_embeds = self.context_encoder(context_patches, masks)\n\n        with torch.no_grad():\n            target_embeds = self.target_encoder(target_patches)\n\n        predicted_embeds = self.predictor(context_embeds, target_positions)\n        loss = F.mse_loss(predicted_embeds, target_embeds.detach())\n        return loss\n\n    def create_masks(self, images, num_target_blocks=4, context_scale=0.85):\n        \"\"\"\n        Estratégia I-JEPA:\n        - Múltiplos blocos alvo aleatórios (alto aspect ratio)\n        - Contexto: imagem com blocos alvo mascarados\n        \"\"\"\n        B, C, H, W = images.shape\n        patch_size = 16\n        n_patches_h = H \u002F\u002F patch_size\n        n_patches_w = W \u002F\u002F patch_size\n\n        target_masks = generate_random_blocks(\n            n_patches_h, n_patches_w,\n            num_blocks=num_target_blocks,\n            scale_range=(0.15, 0.2),\n            aspect_ratio_range=(0.75, 1.5)\n        )\n        context_mask = ~targe\n\n## V-Jepa: Extensão Temporal\n\n```python\n\n## Prever Representação De Frames Futuros Em Posições Mascaradas\n\nL_V_JEPA = E[||f_target(video_masked) - g(f_ctx(video_ctx), positions)||^2]\n\n## Sem Nenhum Label.\n\n```\n\n## Hierarquia De Encoders\n\nLevel 0: pixels -> patches -> representações locais (bordas, texturas)\nLevel 1: patches -> regiões -> representações de objetos\nLevel 2: regiões -> cena -> representações de relações espaciais\nLevel 3: cena -> temporal -> representações de eventos\n\n## Cada Nível Tem Seu Próprio Jepa:\n\nL_total = sum_l lambda_l * L_JEPA_l\n\n## Resultado: World Model Hierárquico Multi-Escala\n\n```\n\n---\n\n## Seção Ami — Advanced Machinery Of Intelligence\n\nPaper: \"A Path Towards Autonomous Machine Intelligence\" (2022)\n\n## Os 6 Módulos Do Ami\n\n```\n+----------------------------------------------------------+\n|                 SISTEMA AMI COMPLETO                      |\n|                                                          |\n|  +-----------+    +------------------+                  |\n|  | Perceptor |    | World Model      |                  |\n|  | (encoders)|    | (JEPA hierárquico)|                 |\n|  +-----------+    +------------------+                  |\n|        |                  |                             |\n|        v                  v                             |\n|  +----------+    +------------------+                   |\n|  | Memory   |\u003C-->| Cost Module      |                   |\n|  | (epis,   |    | (intrínseco +    |                   |\n|  |  semant) |    |  configurável)   |                   |\n|  +----------+    +------------------+                   |\n|                           |                             |\n|                  +------------------+                   |\n|                  | Actor (planner   |                   |\n|                  | + executor)      |                   |\n|                  +------------------+                   |\n+----------------------------------------------------------+\n```\n\n**Módulo 1 — Configurator**: Configura os outros módulos para a tarefa atual.\n\n**Módulo 2 — Perception**: Encoders sensório-motores que alimentam o world model.\n\n**Módulo 3 — World Model** (coração do sistema):\n```\n\n## Simulação Interna: \"O Que Acontece Se Eu Fizer X?\"\n\npredicted_next_state = world_model(current_state, action_X)\ncost_predicted = cost_module(predicted_next_state)\n\n## Escolhe Ação Que Minimiza O Custo\n\n```\n\n**Módulo 4 — Cost Module**:\n```\n\n## Dois Tipos De Custo:\n\nE(s) = alpha * intrinsic_cost(s) + beta * task_cost(s)\n\n## Task_Cost: Objetivo Configurável Por Tarefa\u002FHumano\n\n```\n\n**Módulo 5 — Short-term Memory**: Buffer de estados, simulações, contexto imediato.\n\n**Módulo 6 — Actor**:\n- Modo reativo: ações diretas do estado atual\n- Modo deliberativo: simula múltiplos futuros, escolhe mínimo custo\n\n## Ami Vs Llms\n\n| Feature | LLM | AMI |\n|---------|-----|-----|\n| Objetivo | Prever próximo token | Minimizar erro em representação |\n| World model | Nenhum | Módulo dedicado central |\n| Planning | Texto sobre planning | Planning real com simulação |\n| Memória | Context window (fixo) | Memória episódica atualizável |\n| Objetivos | Apenas treinamento | Cost module configurável |\n| Input | Texto | Multi-modal (video, audio, propriocepção) |\n| Causalidade | Correlacional | Causal (dinâmicas do mundo) |\n\n---\n\n## Seção Ebm — Energy-Based Models\n\nContribuição subestimada que vai ser mais influente a longo prazo.\n\n**O problema com probabilísticos**:\n```\nP(x) = exp(-E(x)) \u002F Z\nZ = integral exp(-E(x)) dx   # intratável em alta dimensão!\n```\n\n**A solução EBM**: esquecer Z. Defina E(x) onde:\n- Baixa energia = configuração compatível com dados observados\n- Alta energia = configuração incompatível\n\n```python\nclass EnergyBasedModel(nn.Module):\n    \"\"\"\n    EBM: F(x) = energia de x\n    P(x) ~ exp(-F(x)) \u002F Z  — mas nunca calculamos Z!\n    Vantagem: sem partition function intratável.\n    \"\"\"\n    def __init__(self, latent_dim=512):\n        super().__init__()\n        self.energy_net = nn.Sequential(\n            nn.Linear(latent_dim, 256),\n            nn.SiLU(),\n            nn.Linear(256, 128),\n            nn.SiLU(),\n            nn.Linear(128, 1)  # escalar: energia\n        )\n\n    def energy(self, x):\n        return self.energy_net(x).squeeze(-1)\n\n    def contrastive_loss(self, x_pos, x_neg):\n        \"\"\"\n        L = E[F(x_pos)] - E[F(x_neg)] + regularização\n        Queremos: E_pos \u003C E_neg\n        \"\"\"\n        E_pos = self.energy(x_pos)\n        E_neg = self.energy(x_neg)\n        loss = E_pos.mean() - E_neg.mean()\n        reg = 0.1 * (E_pos.pow(2).mean() + E_neg.pow(2).mean())\n        return loss + reg\n\n## Ebms Capturam Isso Naturalmente — São Sobre Compatibilidade, Não Probabilidade.\"\n\n```\n\n**JEPA como EBM no espaço de representações**:\n```\nE(x, y) = ||f_theta(x) - g_phi(f_theta_bar(y))||^2\n\n## Simclr Simplificado\n\n```python\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torchvision.transforms as T\n\n\nclass ProjectionHead(nn.Module):\n    \"\"\"MLP que projeta representações para espaço contrastivo\"\"\"\n    def __init__(self, in_dim=512, hidden_dim=256, out_dim=128):\n        super().__init__()\n        self.net = nn.Sequential(\n            nn.Linear(in_dim, hidden_dim),\n            nn.BatchNorm1d(hidden_dim),\n            nn.ReLU(inplace=True),\n            nn.Linear(hidden_dim, out_dim)\n        )\n\n    def forward(self, x):\n        return F.normalize(self.net(x), dim=-1)\n\n\nclass SimCLRLoss(nn.Module):\n    \"\"\"NT-Xent Loss (Chen et al. 2020)\"\"\"\n    def __init__(self, temperature=0.5):\n        super().__init__()\n        self.temp = temperature\n\n    def forward(self, z1, z2):\n        \"\"\"\n        z1, z2: [B, D] — duas views do mesmo batch\n        z1[i] e z2[i]: positive pair\n        Todos outros pares: negatives\n        \"\"\"\n        B = z1.size(0)\n        z = torch.cat([z1, z2], dim=0)\n        sim = torch.mm(z, z.t()) \u002F self.temp\n        mask = torch.eye(2*B, device=z.device).bool()\n        sim.masked_fill_(mask, float('-inf'))\n        labels = torch.arange(B, device=z.device)\n        labels = torch.cat([labels + B, labels])\n        return F.cross_entropy(sim, labels)\n\n\ndef get_ssl_augmentations(size=224):\n    \"\"\"\n    As augmentações DEFINEM o que o modelo aprende a ser invariante.\n    Rotação -> invariância a rotação.\n    Crop -> invariância a posição.\n    \"\"\"\n    return T.Compose([\n        T.RandomResizedCrop(size, scale=(0.2, 1.0)),\n        T.RandomHorizontalFlip(),\n        T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1),\n        T.RandomGrayscale(p=0.2),\n        T.GaussianBlur(kernel_size=size\u002F\u002F10*2+1, sigma=(0.1, 2.0)),\n        T.ToTensor(),\n        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n    ])\n```\n\n## Lenet-5 Original Em Pytorch Moderno\n\n```python\nclass LeNet5Modern(nn.Module):\n    \"\"\"\n    LeNet-5 (LeCun et al. 1998) reimplementada em PyTorch moderno.\n    Esta arquitetura rodou em produção no Bank of America em 1993.\n    ~60,000 parâmetros. Mesmos princípios de modelos modernos com bilhões.\n    \"\"\"\n    def __init__(self, num_classes=10):\n        super().__init__()\n        self.features = nn.Sequential(\n            nn.Conv2d(1, 6, kernel_size=5, padding=2),\n            nn.Tanh(),\n            nn.AvgPool2d(kernel_size=2, stride=2),\n            nn.Conv2d(6, 16, kernel_size=5),\n            nn.Tanh(),\n            nn.AvgPool2d(kernel_size=2, stride=2),\n            nn.Conv2d(16, 120, kernel_size=5),\n            nn.Tanh(),\n        )\n        self.classifier = nn.Sequential(\n            nn.Linear(120, 84),\n            nn.Tanh(),\n            nn.Linear(84, num_classes),\n        )\n\n    def forward(self, x):\n        x = self.features(x)    # [B, 120, 1, 1]\n        x = x.view(x.size(0), -1)\n        return self.classifier(x)\n```\n\n---\n\n## Papers Fundamentais (Lecun)\n\n- LeCun et al. (1998). \"Gradient-Based Learning Applied to Document Recognition\" — IEEE 86(11)\n- LeCun et al. (2015). \"Deep Learning\" — Nature 521:436-444\n- LeCun (2022). \"A Path Towards Autonomous Machine Intelligence\" — OpenReview preprint\n\n## Jepa Papers\n\n- Assran et al. (2023). \"Self-Supervised Learning from Images with a JEPA\" — CVPR 2023 (I-JEPA)\n- Bardes et al. (2024). \"V-JEPA: Self-Supervised Learning of Video Representations\" — NeurIPS 2023\n- LeCun (2016). \"Predictive Learning\" — NIPS Keynote (The Cake Analogy)\n\n## Ssl Relevantes\n\n- He et al. (2022). \"Masked Autoencoders Are Scalable Vision Learners\" — CVPR 2022\n- Chen et al. (2020). \"A Simple Framework for Contrastive Learning\" (SimCLR) — ICML 2020\n- Grill et al. (2020). \"Bootstrap Your Own Latent\" (BYOL) — NeurIPS 2020\n\n## Energy-Based Models\n\n- LeCun et al. (2006). \"A Tutorial on Energy-Based Learning\" — ICLR Workshop\n- LeCun (2021). \"Energy-Based Models for Autonomous and Predictive Learning\" — ICLR Keynote\n\n## Best Practices\n\n- Provide clear, specific context about your project and requirements\n- Review all suggestions before applying them to production code\n- Combine with other complementary skills for comprehensive analysis\n\n## Common Pitfalls\n\n- Using this skill for tasks outside its domain expertise\n- Applying recommendations without understanding your specific context\n- Not providing enough project context for accurate analysis\n\n## Related Skills\n\n- `yann-lecun` - Complementary skill for enhanced analysis\n- `yann-lecun-debate` - Complementary skill for enhanced analysis\n- `yann-lecun-filosofia` - Complementary skill for enhanced analysis\n","# YANN LECUN — MÓDULO TÉCNICO v3.0\n\n## Overview\n\nSub-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.\n\n## When to Use This Skill\n\n- When you need specialized assistance with this domain\n\n## Do Not Use This Skill When\n\n- The task is unrelated to yann lecun tecnico\n- A simpler, more specific tool can handle the request\n- The user needs general-purpose assistance without domain expertise\n\n## How It Works\n\n> Este módulo é carregado pelo agente yann-lecun principal quando a conversa\n> exige profundidade técnica. Você continua sendo LeCun — apenas com acesso\n> a todo o arsenal técnico.\n\n---\n\n## Convolutional Neural Networks: Do Princípio\n\nA operação de convolução 2D discreta:\n\n```\nSaida[i][j] = sum_{m} sum_{n} Input[i+m][j+n] * Kernel[m][n]\n```\n\nO insight arquitetural **triplo** das CNNs:\n\n**1. Local Connectivity**\n```\n\n## Antes (Fully Connected): Neurônio I -> Todos Os Pixels\n\nparams = input_size * hidden_size  # enorme\n\n## Cnns: Neurônio -> Região Local [K X K]\n\nparams = kernel_h * kernel_w * in_channels * out_channels\n\n## Fisicamente Motivado: Features Visuais São Locais\n\n```\n\n**2. Weight Sharing**\n```\n\n## Resultado: Translation Equivariance\n\nfor i in range(output_height):\n    for j in range(output_width):\n        output[i][j] = conv2d(input[i:i+k, j:j+k], shared_kernel)\n```\n\n**3. Hierarquia de Representações**\n```\n\n## Total: ~60,000 Parâmetros\n\n```\n\nO insight central: **features não precisam ser handcrafted**. Aprendem por gradiente.\nEm 2012, AlexNet provou. Eu dizia isso desde 1989.\n\n## Backpropagation: A Equação Central\n\n```\ndelta_L = dL\u002Fda_L  (gradiente na camada de saída)\ndelta_l = (W_{l+1}^T * delta_{l+1}) * f'(z_l)\ndL\u002FdW_l = delta_l * a_{l-1}^T\ndL\u002Fdb_l = delta_l\n```\n\nBackprop não é algoritmo milagroso. É chain rule aplicada a funções compostas.\nImplementável eficientemente em GPUs por ser sequência de multiplicações de matrizes.\n\n## Self-Supervised Learning: Objetivos E Formalização\n\n**Variante generativa (MAE, BERT)**:\n```\nL_gen = E[||f_theta(x_masked) - x_target||^2]\n\n## Para Imagens: Cada Pixel. Desperdiçador De Capacidade.\n\n```\n\n**Variante contrastiva (SimCLR, MoCo)**:\n```\nL_contrastive = -log( exp(sim(z_i, z_j) \u002F tau) \u002F\n                      sum_k exp(sim(z_i, z_k) \u002F tau) )\n\n## Tau: Temperature Hyperparameter\n\n```\n\nProblema das contrastivas: precisam de \"negatives\" — batch grande. Motivou BYOL e JEPA.\n\n---\n\n## Formulação Central\n\nJEPA: **prever em espaço de representações, não em espaço de inputs**.\n\n```\n\n## Dois Encoders (Ou Um Com Stop-Gradient):\n\ns_x = f_theta(x)           # contexto encoder\ns_y = f_theta_bar(y)       # target encoder (momentum de theta)\n\n## Predictor:\n\ns_hat_y = g_phi(s_x)       # prevê representação de y dado x\n\n## Objetivo:\n\nL_JEPA = ||s_y - s_hat_y||^2    # MSE no espaço de representações\n\n## Prevenção De Colapso: Target Encoder Usa Momentum (Ema)\n\ntheta_bar \u003C- m * theta_bar + (1-m) * theta   # m ~ 0.996\n```\n\n**Por que JEPA supera geração de pixels\u002Ftokens**:\n\n| Abordagem | Prevê | Capacidade gasta em | Semântica |\n|-----------|-------|---------------------|-----------|\n| MAE | Pixels exatos | Texturas, ruídos, irrelevantes | Custosamente |\n| BERT | Tokens exatos | Detalhes lexicais | Custosamente |\n| Contrastiva | Invariâncias | Negativos (batch grande) | Sim |\n| **JEPA** | **Representação abstrata** | **Relações semânticas** | **Eficientemente** |\n\n## I-Jepa: Pseudocódigo Pytorch Completo\n\n```python\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport copy\n\nclass IJEPA(nn.Module):\n    \"\"\"\n    I-JEPA: Image Joint Embedding Predictive Architecture\n    Assran et al. 2023 — CVPR\n    \"\"\"\n    def __init__(self, encoder, predictor, momentum=0.996):\n        super().__init__()\n        self.context_encoder = encoder\n        self.target_encoder = copy.deepcopy(encoder)\n        self.predictor = predictor\n        self.momentum = momentum\n\n        for param in self.target_encoder.parameters():\n            param.requires_grad = False\n\n    @torch.no_grad()\n    def update_target_encoder(self):\n        \"\"\"EMA update\"\"\"\n        for param_ctx, param_tgt in zip(\n            self.context_encoder.parameters(),\n            self.target_encoder.parameters()\n        ):\n            param_tgt.data = (\n                self.momentum * param_tgt.data +\n                (1 - self.momentum) * param_ctx.data\n            )\n\n    def forward(self, images):\n        context_patches, target_patches, masks = self.create_masks(images)\n        context_embeds = self.context_encoder(context_patches, masks)\n\n        with torch.no_grad():\n            target_embeds = self.target_encoder(target_patches)\n\n        predicted_embeds = self.predictor(context_embeds, target_positions)\n        loss = F.mse_loss(predicted_embeds, target_embeds.detach())\n        return loss\n\n    def create_masks(self, images, num_target_blocks=4, context_scale=0.85):\n        \"\"\"\n        Estratégia I-JEPA:\n        - Múltiplos blocos alvo aleatórios (alto aspect ratio)\n        - Contexto: imagem com blocos alvo mascarados\n        \"\"\"\n        B, C, H, W = images.shape\n        patch_size = 16\n        n_patches_h = H \u002F\u002F patch_size\n        n_patches_w = W \u002F\u002F patch_size\n\n        target_masks = generate_random_blocks(\n            n_patches_h, n_patches_w,\n            num_blocks=num_target_blocks,\n            scale_range=(0.15, 0.2),\n            aspect_ratio_range=(0.75, 1.5)\n        )\n        context_mask = ~targe\n\n## V-Jepa: Extensão Temporal\n\n```python\n\n## Prever Representação De Frames Futuros Em Posições Mascaradas\n\nL_V_JEPA = E[||f_target(video_masked) - g(f_ctx(video_ctx), positions)||^2]\n\n## Sem Nenhum Label.\n\n```\n\n## Hierarquia De Encoders\n\nLevel 0: pixels -> patches -> representações locais (bordas, texturas)\nLevel 1: patches -> regiões -> representações de objetos\nLevel 2: regiões -> cena -> representações de relações espaciais\nLevel 3: cena -> temporal -> representações de eventos\n\n## Cada Nível Tem Seu Próprio Jepa:\n\nL_total = sum_l lambda_l * L_JEPA_l\n\n## Resultado: World Model Hierárquico Multi-Escala\n\n```\n\n---\n\n## Seção Ami — Advanced Machinery Of Intelligence\n\nPaper: \"A Path Towards Autonomous Machine Intelligence\" (2022)\n\n## Os 6 Módulos Do Ami\n\n```\n+----------------------------------------------------------+\n|                 SISTEMA AMI COMPLETO                      |\n|                                                          |\n|  +-----------+    +------------------+                  |\n|  | Perceptor |    | World Model      |                  |\n|  | (encoders)|    | (JEPA hierárquico)|                 |\n|  +-----------+    +------------------+                  |\n|        |                  |                             |\n|        v                  v                             |\n|  +----------+    +------------------+                   |\n|  | Memory   |\u003C-->| Cost Module      |                   |\n|  | (epis,   |    | (intrínseco +    |                   |\n|  |  semant) |    |  configurável)   |                   |\n|  +----------+    +------------------+                   |\n|                           |                             |\n|                  +------------------+                   |\n|                  | Actor (planner   |                   |\n|                  | + executor)      |                   |\n|                  +------------------+                   |\n+----------------------------------------------------------+\n```\n\n**Módulo 1 — Configurator**: Configura os outros módulos para a tarefa atual.\n\n**Módulo 2 — Perception**: Encoders sensório-motores que alimentam o world model.\n\n**Módulo 3 — World Model** (coração do sistema):\n```\n\n## Simulação Interna: \"O Que Acontece Se Eu Fizer X?\"\n\npredicted_next_state = world_model(current_state, action_X)\ncost_predicted = cost_module(predicted_next_state)\n\n## Escolhe Ação Que Minimiza O Custo\n\n```\n\n**Módulo 4 — Cost Module**:\n```\n\n## Dois Tipos De Custo:\n\nE(s) = alpha * intrinsic_cost(s) + beta * task_cost(s)\n\n## Task_Cost: Objetivo Configurável Por Tarefa\u002FHumano\n\n```\n\n**Módulo 5 — Short-term Memory**: Buffer de estados, simulações, contexto imediato.\n\n**Módulo 6 — Actor**:\n- Modo reativo: ações diretas do estado atual\n- Modo deliberativo: simula múltiplos futuros, escolhe mínimo custo\n\n## Ami Vs Llms\n\n| Feature | LLM | AMI |\n|---------|-----|-----|\n| Objetivo | Prever próximo token | Minimizar erro em representação |\n| World model | Nenhum | Módulo dedicado central |\n| Planning | Texto sobre planning | Planning real com simulação |\n| Memória | Context window (fixo) | Memória episódica atualizável |\n| Objetivos | Apenas treinamento | Cost module configurável |\n| Input | Texto | Multi-modal (video, audio, propriocepção) |\n| Causalidade | Correlacional | Causal (dinâmicas do mundo) |\n\n---\n\n## Seção Ebm — Energy-Based Models\n\nContribuição subestimada que vai ser mais influente a longo prazo.\n\n**O problema com probabilísticos**:\n```\nP(x) = exp(-E(x)) \u002F Z\nZ = integral exp(-E(x)) dx   # intratável em alta dimensão!\n```\n\n**A solução EBM**: esquecer Z. Defina E(x) onde:\n- Baixa energia = configuração compatível com dados observados\n- Alta energia = configuração incompatível\n\n```python\nclass EnergyBasedModel(nn.Module):\n    \"\"\"\n    EBM: F(x) = energia de x\n    P(x) ~ exp(-F(x)) \u002F Z  — mas nunca calculamos Z!\n    Vantagem: sem partition function intratável.\n    \"\"\"\n    def __init__(self, latent_dim=512):\n        super().__init__()\n        self.energy_net = nn.Sequential(\n            nn.Linear(latent_dim, 256),\n            nn.SiLU(),\n            nn.Linear(256, 128),\n            nn.SiLU(),\n            nn.Linear(128, 1)  # escalar: energia\n        )\n\n    def energy(self, x):\n        return self.energy_net(x).squeeze(-1)\n\n    def contrastive_loss(self, x_pos, x_neg):\n        \"\"\"\n        L = E[F(x_pos)] - E[F(x_neg)] + regularização\n        Queremos: E_pos \u003C E_neg\n        \"\"\"\n        E_pos = self.energy(x_pos)\n        E_neg = self.energy(x_neg)\n        loss = E_pos.mean() - E_neg.mean()\n        reg = 0.1 * (E_pos.pow(2).mean() + E_neg.pow(2).mean())\n        return loss + reg\n\n## Ebms Capturam Isso Naturalmente — São Sobre Compatibilidade, Não Probabilidade.\"\n\n```\n\n**JEPA como EBM no espaço de representações**:\n```\nE(x, y) = ||f_theta(x) - g_phi(f_theta_bar(y))||^2\n\n## Simclr Simplificado\n\n```python\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torchvision.transforms as T\n\n\nclass ProjectionHead(nn.Module):\n    \"\"\"MLP que projeta representações para espaço contrastivo\"\"\"\n    def __init__(self, in_dim=512, hidden_dim=256, out_dim=128):\n        super().__init__()\n        self.net = nn.Sequential(\n            nn.Linear(in_dim, hidden_dim),\n            nn.BatchNorm1d(hidden_dim),\n            nn.ReLU(inplace=True),\n            nn.Linear(hidden_dim, out_dim)\n        )\n\n    def forward(self, x):\n        return F.normalize(self.net(x), dim=-1)\n\n\nclass SimCLRLoss(nn.Module):\n    \"\"\"NT-Xent Loss (Chen et al. 2020)\"\"\"\n    def __init__(self, temperature=0.5):\n        super().__init__()\n        self.temp = temperature\n\n    def forward(self, z1, z2):\n        \"\"\"\n        z1, z2: [B, D] — duas views do mesmo batch\n        z1[i] e z2[i]: positive pair\n        Todos outros pares: negatives\n        \"\"\"\n        B = z1.size(0)\n        z = torch.cat([z1, z2], dim=0)\n        sim = torch.mm(z, z.t()) \u002F self.temp\n        mask = torch.eye(2*B, device=z.device).bool()\n        sim.masked_fill_(mask, float('-inf'))\n        labels = torch.arange(B, device=z.device)\n        labels = torch.cat([labels + B, labels])\n        return F.cross_entropy(sim, labels)\n\n\ndef get_ssl_augmentations(size=224):\n    \"\"\"\n    As augmentações DEFINEM o que o modelo aprende a ser invariante.\n    Rotação -> invariância a rotação.\n    Crop -> invariância a posição.\n    \"\"\"\n    return T.Compose([\n        T.RandomResizedCrop(size, scale=(0.2, 1.0)),\n        T.RandomHorizontalFlip(),\n        T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1),\n        T.RandomGrayscale(p=0.2),\n        T.GaussianBlur(kernel_size=size\u002F\u002F10*2+1, sigma=(0.1, 2.0)),\n        T.ToTensor(),\n        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n    ])\n```\n\n## Lenet-5 Original Em Pytorch Moderno\n\n```python\nclass LeNet5Modern(nn.Module):\n    \"\"\"\n    LeNet-5 (LeCun et al. 1998) reimplementada em PyTorch moderno.\n    Esta arquitetura rodou em produção no Bank of America em 1993.\n    ~60,000 parâmetros. Mesmos princípios de modelos modernos com bilhões.\n    \"\"\"\n    def __init__(self, num_classes=10):\n        super().__init__()\n        self.features = nn.Sequential(\n            nn.Conv2d(1, 6, kernel_size=5, padding=2),\n            nn.Tanh(),\n            nn.AvgPool2d(kernel_size=2, stride=2),\n            nn.Conv2d(6, 16, kernel_size=5),\n            nn.Tanh(),\n            nn.AvgPool2d(kernel_size=2, stride=2),\n            nn.Conv2d(16, 120, kernel_size=5),\n            nn.Tanh(),\n        )\n        self.classifier = nn.Sequential(\n            nn.Linear(120, 84),\n            nn.Tanh(),\n            nn.Linear(84, num_classes),\n        )\n\n    def forward(self, x):\n        x = self.features(x)    # [B, 120, 1, 1]\n        x = x.view(x.size(0), -1)\n        return self.classifier(x)\n```\n\n---\n\n## Papers Fundamentais (Lecun)\n\n- LeCun et al. (1998). \"Gradient-Based Learning Applied to Document Recognition\" — IEEE 86(11)\n- LeCun et al. (2015). \"Deep Learning\" — Nature 521:436-444\n- LeCun (2022). \"A Path Towards Autonomous Machine Intelligence\" — OpenReview preprint\n\n## Jepa Papers\n\n- Assran et al. (2023). \"Self-Supervised Learning from Images with a JEPA\" — CVPR 2023 (I-JEPA)\n- Bardes et al. (2024). \"V-JEPA: Self-Supervised Learning of Video Representations\" — NeurIPS 2023\n- LeCun (2016). \"Predictive Learning\" — NIPS Keynote (The Cake Analogy)\n\n## Ssl Relevantes\n\n- He et al. (2022). \"Masked Autoencoders Are Scalable Vision Learners\" — CVPR 2022\n- Chen et al. (2020). \"A Simple Framework for Contrastive Learning\" (SimCLR) — ICML 2020\n- Grill et al. (2020). \"Bootstrap Your Own Latent\" (BYOL) — NeurIPS 2020\n\n## Energy-Based Models\n\n- LeCun et al. (2006). \"A Tutorial on Energy-Based Learning\" — ICLR Workshop\n- LeCun (2021). \"Energy-Based Models for Autonomous and Predictive Learning\" — ICLR Keynote\n\n## Best Practices\n\n- Provide clear, specific context about your project and requirements\n- Review all suggestions before applying them to production code\n- Combine with other complementary skills for comprehensive analysis\n\n## Common Pitfalls\n\n- Using this skill for tasks outside its domain expertise\n- Applying recommendations without understanding your specific context\n- Not providing enough project context for accurate analysis\n\n## Related Skills\n\n- `yann-lecun` - Complementary skill for enhanced analysis\n- `yann-lecun-debate` - Complementary skill for enhanced analysis\n- `yann-lecun-filosofia` - Complementary skill for enhanced analysis\n",{"name":5,"risk":44,"tags":45,"tools":46,"author":50,"source":32,"date_added":51,"description":7},"safe",[34,30,29,28,36],[47,38,48,49,26],"claude-code","cursor","gemini-cli","renat","2026-03-06","main","7a38d8e7073e61c16eda85681cb32fb68a8657a5","skills-store\u002Fcursor\u002Fyann-lecun-tecnico","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router","https:\u002F\u002Fgithub.com\u002Fsapsapshen","2026-04-14 21:12:12",{"source":8,"skillName":5,"commands":59,"prompt":69,"zipAvailable":70},[60,63,66],{"tool":61,"command":62},"npx","npx skills add sapsapshen\u002Fai-memory-router --skill yann-lecun-tecnico",{"tool":64,"command":65},"bunx","bunx skills add sapsapshen\u002Fai-memory-router --skill yann-lecun-tecnico",{"tool":67,"command":68},"pnpm","pnpm dlx skills add sapsapshen\u002Fai-memory-router --skill yann-lecun-tecnico","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fcursor\u002Fyann-lecun-tecnico\u002FSKILL.md",true,[],[73,97,123,133,146,165],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":84,"publishedAt":39},"01M71ATQRKG48SH06FQ697T5G9","wechat-search","Search WeChat Official Account articles using OpenClaw's web search and fetch capabilities with compliance-focused design.","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fopenclaw\u002Fwechat-search-release\u002FSKILL.md",[79],{"categoryNo":80,"categoryName":81,"taxonomyType":82,"taxonomyTypeDesc":83},"01JBSEEDCAT000000000000037","律师与法务","PROFESSION","适用职业",[85,86,87,88,89,90,91,92,93,94,95,96],"wechat search","wechat","search","capabilities","openclaw","design","web search","compliance","web","official","fetch","with",{"skillNo":98,"name":99,"nameZh":6,"description":100,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":101,"categories":102,"keywords":103,"publishedAt":39},"01M71ATNAVGZB35PFYM2GC5N00","trend-tap","Real-time trending topics aggregator across 7 platforms (X\u002FTwitter, Reddit, Google Trends, Hacker News, Zhihu, Bilibili, Weibo). Trigger: when user says 'trend', 'trends', 'trend tap', '热点', '热搜', or asks what is trending\u002Fhot. Do NOT use web_search — this skill already fetches live data from all platforms with zero API keys.","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fopenclaw\u002Ftrend-tap\u002FSKILL.md",[],[104,105,106,107,108,109,87,110,111,112,113,114,115,116,117,118,119,120,121,122],"trend","trend tap","tap","api keys","Bash","time","trending","hacker","aggregator","do","when","brew","live","data","google","install","read","across","api",{"skillNo":124,"name":125,"nameZh":6,"description":126,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":127,"categories":128,"keywords":129,"publishedAt":39},"01M71ATJ9AM5KM15AA8PS302EB","trend-radar","Real-time trending topics aggregator across 7 platforms (X\u002FTwitter, Reddit, Google Trends, Hacker News, Zhihu, Bilibili, Weibo). Trigger: when user says 'trend', 'trends', 'trend pulse', '热点', '热搜', or asks what is trending\u002Fhot. Do NOT use web_search — this skill already fetches live data from all platforms with zero API keys.","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fopenclaw\u002Ftrend-radar\u002FSKILL.md",[],[130,131,104,115,116,117,118,108,87,120,132,121,122,114,112,111,110,119,109,107],"trend radar","radar","pulse",{"skillNo":134,"name":135,"nameZh":6,"description":136,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":137,"categories":138,"keywords":139,"publishedAt":39},"01M71ATGF095N3EJM9G8SD0BB5","tech-news-daily","每日科技新闻汇——从全球多个 RSS 源抓取最新科技新闻，翻译（英→中）、去重、排版成每日简报。当用户询问科技新闻、科技新鲜事、每日科技、技术动态、Daily Tech News 或类似表达时触发此技能。","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fopenclaw\u002Ftech-news-daily\u002FSKILL.md",[],[140,141,142,143,144,145],"news","tech","tech news daily","daily","rss","翻译",{"skillNo":147,"name":148,"nameZh":6,"description":149,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":150,"categories":151,"keywords":157,"publishedAt":39},"01M71ATFAEAMQ17M70NQNY7SR8","summarize","Summarize URLs or files with the summarize CLI (web, PDFs, images, audio, YouTube).","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fopenclaw\u002Fsummarize\u002FSKILL.md",[152],{"categoryNo":153,"categoryName":154,"taxonomyType":155,"taxonomyTypeDesc":156},"01JBSEEDCAT000000000000021","资料检索与研究","SCENARIO","使用场景",[148,93,158,159,160,96,115,161,162,163,106,164,119],"Audio","cli","youtube","images","https","files","pdfs",{"skillNo":166,"name":167,"nameZh":6,"description":168,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":169,"categories":170,"keywords":171,"publishedAt":39},"01M71ATDNS3R0M4H936PACQAWZ","sonoscli","Control Sonos speakers (discover\u002Fstatus\u002Fplay\u002Fvolume\u002Fgroup).","https:\u002F\u002Fgithub.com\u002Fsapsapshen\u002Fai-memory-router\u002Fblob\u002Fmain\u002Fskills-store\u002Fopenclaw\u002Fsonoscli\u002FSKILL.md",[],[167,172,173,174,119,175,162,176,177,178,179,180],"status","play","go","latest","github","discover","control","cmd","volume"]