[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-9298f032-bb47-4e82-bdb3-92bedb846b9d":3,"$fR2nzf-_trq6Wqx2ccpyTl-8NnRpifesmtbmB1ti6HBw":43},{"id":4,"title":5,"description":6,"categoryId":7,"moduleId":8,"tags":9,"prompt":10,"icon":11,"source":12,"sourceUrl":13,"authorId":14,"authorName":15,"isPublic":16,"stars":17,"runs":18,"createdAt":19,"updatedAt":19,"module":20,"category":27,"packages":34},"9298f032-bb47-4e82-bdb3-92bedb846b9d","yann-lecun-tecnico","杨立昆的子技能技术。包括CNNs、LeNet、反向传播、JEPA（I-JEPA、V-JEPA、MC-JEPA）、AMI（高级智能机器）、自监督学习（SimCLR、MAE、BYOL）、基于能量的模型（EBMs）和完整的PyTorch代码。","cat_life_career","mod_other","sickn33,other","---\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","","imported","https:\u002F\u002Fgithub.com\u002Fsickn33\u002Fantigravity-awesome-skills","user_system_seed","SkillOPIC",true,204,1600,"2026-05-16 13:48:10",{"id":8,"name":21,"slug":22,"icon":23,"description":24,"sort":25,"createdAt":26},"其他","other","mdi-page-next-outline","其他类型Skill",5,"2026-05-16 12:53:40",{"id":7,"name":28,"slug":29,"icon":30,"description":31,"moduleId":8,"sort":32,"skillCount":33,"createdAt":26},"职场发展","career","mdi-briefcase-outline","面试准备、简历优化、职业规划",4,575,[35],{"id":36,"skillId":4,"version":37,"fileName":38,"fileSize":39,"filePath":40,"fileHash":41,"manifest":42,"createdAt":19},"fedc5a1f-4697-4931-ab5e-6cc1bf864c9f","1.0.0","yann-lecun-tecnico.zip",6486,"uploads\u002Fskills\u002F9298f032-bb47-4e82-bdb3-92bedb846b9d\u002Fyann-lecun-tecnico.zip","a1fa718c37d5aa58b401dd6ea4387508ff69b0fe748120b56bfaa64b25a11b0e","[{\"path\":\"SKILL.md\",\"isDirectory\":false,\"size\":16021}]",{"code":44,"message":45,"data":46},200,"success",{"items":47,"stats":48,"page":51},[],{"averageRating":49,"totalRatings":49,"ratingCounts":50},0,[49,49,49,49,49],{"limit":52,"offset":49,"hasMore":53,"nextOffset":52,"ratedOnly":16},15,false]