[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7C6CHG2EGM2VBZAF3TMHFDK":3,"skill-same:01M7C6CHG2EGM2VBZAF3TMHFDK":63},{"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":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":40,"commitSha":41,"skillDirectory":42,"forksCount":43,"repositoryHtmlUrl":44,"repositoryHomepageUrl":45,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":47,"updatedAt":48,"install":49,"resources":62},"01M7C6CHG2EGM2VBZAF3TMHFDK","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.","YYC-Cube\u002FYYC3-Knowledge-Base","YYC-Cube","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F235006543?v=4","01M79J2PH4SWD2X0825X6PN748","yyc3","01M79J2PHVK3F6ZBYT8K2SCZCW",1,"MIT","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fplugins\u002Fantigravity-awesome-skills-claude\u002Fskills\u002Fyann-lecun-tecnico\u002FSKILL.md",[],[],"2026-11-15 14:19:17",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\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.\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\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.\n",{"name":5,"risk":24,"tags":25,"tools":31,"author":37,"source":38,"date_added":39,"description":7},"safe",[26,27,28,29,30],"persona","cnn","jepa","self-supervised","pytorch",[32,33,34,35,36],"claude-code","antigravity","cursor","gemini-cli","codex-cli","renat","community","2026-03-06","main","87afe6ce96220accf50a345dea46784c8c9f210e","YYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fplugins\u002Fantigravity-awesome-skills-claude\u002Fskills\u002Fyann-lecun-tecnico",0,"https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base","https:\u002F\u002Fkb.yyc3.top\u002F","https:\u002F\u002Fgithub.com\u002FYYC-Cube","万象归元于云枢 | 深栈智启新纪元","2026-11-10 10:37:32",{"source":8,"skillName":5,"commands":50,"prompt":60,"zipAvailable":61},[51,54,57],{"tool":52,"command":53},"npx","npx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill yann-lecun-tecnico",{"tool":55,"command":56},"bunx","bunx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill yann-lecun-tecnico",{"tool":58,"command":59},"pnpm","pnpm dlx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill yann-lecun-tecnico","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fplugins\u002Fantigravity-awesome-skills-claude\u002Fskills\u002Fyann-lecun-tecnico\u002FSKILL.md",true,[],[64,71,78,85,92,99],{"skillNo":65,"name":66,"nameZh":6,"description":67,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":68,"categories":69,"keywords":70,"publishedAt":19},"01M7CTDWHERCXPQCP0K03A86AS","vercel-sandbox","Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include \"Vercel Sandbox browser\", \"microVM Chrome\", \"agent-browser in sandbox\", \"browser automation on Vercel\", or any task requiring Chrome in a Vercel Sandbox.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fvercel-sandbox\u002FSKILL.md",[],[],{"skillNo":72,"name":73,"nameZh":6,"description":74,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":75,"categories":76,"keywords":77,"publishedAt":19},"01M7CTD8D2BNJY54S65M47HEJA","slack","Interact with Slack workspaces using browser automation. Use when the user needs to check unread channels, navigate Slack, send messages, extract data, find information, search conversations, or automate any Slack task. Triggers include \"check my Slack\", \"what channels have unreads\", \"send a message to\", \"search Slack for\", \"extract from Slack\", \"find who said\", or any task requiring programmatic Slack interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fslack\u002FSKILL.md",[],[],{"skillNo":79,"name":80,"nameZh":6,"description":81,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":82,"categories":83,"keywords":84,"publishedAt":19},"01M7CTCSSB8ZP3Q58C3YZDZK1W","electron","Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include \"automate Slack app\", \"control VS Code\", \"interact with Discord app\", \"test this Electron app\", \"connect to desktop app\", or any task requiring automation of a native Electron application.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Felectron\u002FSKILL.md",[],[],{"skillNo":86,"name":87,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":89,"categories":90,"keywords":91,"publishedAt":19},"01M7CTCBJY76688V4DCZGWFHGQ","dogfood","Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to \"dogfood\", \"QA\", \"exploratory test\", \"find issues\", \"bug hunt\", \"test this app\u002Fsite\u002Fplatform\", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fdogfood\u002FSKILL.md",[],[],{"skillNo":93,"name":94,"nameZh":6,"description":95,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":96,"categories":97,"keywords":98,"publishedAt":19},"01M7CTC4H0FFGVEAQR9PA4GA1A","agent-browser","Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to \"open a website\", \"fill out a form\", \"click a button\", \"take a screenshot\", \"scrape data from a page\", \"test this web app\", \"login to a site\", \"automate browser actions\", or any task requiring programmatic web interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fagent-browser\u002FSKILL.md",[],[],{"skillNo":100,"name":101,"nameZh":6,"description":102,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":103,"categories":104,"keywords":105,"publishedAt":19},"01M7CTBKVFYBG78FDSABSDJTTQ","shadcn","Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI, including chat interfaces. Provides project context, component docs, and usage examples. Applies when working with shadcn\u002Fui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for \"shadcn init\", \"create an app with --preset\", \"switch to --preset\", and for building a design system or applying a DESIGN.md or brand spec to shadcn\u002Fui.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-UI-界面组件\u002FYYC3-UI-界面组件-ui\u002Fskills\u002Fshadcn\u002FSKILL.md",[],[]]