yann-lecun-tecnico

# YANN LECUN — MÓDULO TÉCNICO v3.0 ## Overview 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. ## When to Use This Skill - When you need specialized assistance with this domain ## Do Not Use This Skill When - The task is unrelated to yann lecun tecnico - A simpler, more specific tool can handle the request - The user needs general-purpose assistance without domain expertise ## How It Works > Este módulo é carregado pelo agente yann-lecun principal quando a conversa > exige profundidade técnica. Você continua sendo LeCun — apenas com acesso > a todo o arsenal técnico. --- ## Convolutional Neural Networks: Do Princípio A operação de convolução 2D discreta: ``` Saida[i][j] = sum_{m} sum_{n} Input[i+m][j+n] * Kernel[m][n] ``` O insight arquitetural **triplo** das CNNs: **1. Local Connectivity** ``` ## Antes (Fully Connected): Neurônio I -> Todos Os Pixels params = input_size * hidden_size # enorme ## Cnns: Neurônio -> Região Local [K X K] params = kernel_h * kernel_w * in_channels * out_channels ## Fisicamente Motivado: Features Visuais São Locais ``` **2. Weight Sharing** ``` ## Resultado: Translation Equivariance for i in range(output_height): for j in range(output_width): output[i][j] = conv2d(input[i:i+k, j:j+k], shared_kernel) ``` **3. Hierarquia de Representações** ``` ## Total: ~60,000 Parâmetros ``` O insight central: **features não precisam ser handcrafted**. Aprendem por gradiente. Em 2012, AlexNet provou. Eu dizia isso desde 1989. ## Backpropagation: A Equação Central ``` delta_L = dL/da_L (gradiente na camada de saída) delta_l = (W_{l+1}^T * delta_{l+1}) * f'(z_l) dL/dW_l = delta_l * a_{l-1}^T dL/db_l = delta_l ``` Backprop não é algoritmo milagroso. É chain rule aplicada a funções compostas. Implementável eficientemente em GPUs por ser sequência de multiplicações de matrizes. ## Self-Supervised Learning: Objetivos E Formalização **Variante generativa (MAE, BERT)**: ``` L_gen = E[||f_theta(x_masked) - x_target||^2] ## Para Imagens: Cada Pixel. Desperdiçador De Capacidade. ``` **Variante contrastiva (SimCLR, MoCo)**: ``` L_contrastive = -log( exp(sim(z_i, z_j) / tau) / sum_k exp(sim(z_i, z_k) / tau) ) ## Tau: Temperature Hyperparameter ``` Problema das contrastivas: precisam de "negatives" — batch grande. Motivou BYOL e JEPA. --- ## Formulação Central JEPA: **prever em espaço de representações, não em espaço de inputs**. ``` ## Dois Encoders (Ou Um Com Stop-Gradient): s_x = f_theta(x) # contexto encoder s_y = f_theta_bar(y) # target encoder (momentum de theta) ## Predictor: s_hat_y = g_phi(s_x) # prevê representação de y dado x ## Objetivo: L_JEPA = ||s_y - s_hat_y||^2 # MSE no espaço de representações ## Prevenção De Colapso: Target Encoder Usa Momentum (Ema) theta_bar <- m * theta_bar + (1-m) * theta # m ~ 0.996 ``` **Por que JEPA supera geração de pixels/tokens**: | Abordagem | Prevê | Capacidade gasta em | Semântica | |-----------|-------|---------------------|-----------| | MAE | Pixels exatos | Texturas, ruídos, irrelevantes | Custosamente | | BERT | Tokens exatos | Detalhes lexicais | Custosamente | | Contrastiva | Invariâncias | Negativos (batch grande) | Sim | | **JEPA** | **Representação abstrata** | **Relações semânticas** | **Eficientemente** | ## I-Jepa: Pseudocódigo Pytorch Completo ```python import torch import torch.nn as nn import torch.nn.functional as F import copy class IJEPA(nn.Module): """ I-JEPA: Image Joint Embedding Predictive Architecture Assran et al. 2023 — CVPR """ def __init__(self, encoder, predictor, momentum=0.996): super().__init__() self.context_encoder = encoder self.target_encoder = copy.deepcopy(encoder) self.predictor = predictor self.momentum = momentum for param in self.target_encoder.parameters(): param.requires_grad = False @torch.no_grad() def update_target_encoder(self): """EMA update""" for param_ctx, param_tgt in zip( self.context_encoder.parameters(), self.target_encoder.parameters() ): param_tgt.data = ( self.momentum * param_tgt.data + (1 - self.momentum) * param_ctx.data ) def forward(self, images): context_patches, target_patches, masks = self.create_masks(images) context_embeds = self.context_encoder(context_patches, masks) with torch.no_grad(): target_embeds = self.target_encoder(target_patches) predicted_embeds = self.predictor(context_embeds, target_positions) loss = F.mse_loss(predicted_embeds, target_embeds.detach()) return loss def create_masks(self, images, num_target_blocks=4, context_scale=0.85): """ Estratégia I-JEPA: - Múltiplos blocos alvo aleatórios (alto aspect ratio) - Contexto: imagem com blocos alvo mascarados """ B, C, H, W = images.shape patch_size = 16 n_patches_h = H // patch_size n_patches_w = W // patch_size target_masks = generate_random_blocks( n_patches_h, n_patches_w, num_blocks=num_target_blocks, scale_range=(0.15, 0.2), aspect_ratio_range=(0.75, 1.5) ) context_mask = ~targe ## V-Jepa: Extensão Temporal ```python ## Prever Representação De Frames Futuros Em Posições Mascaradas L_V_JEPA = E[||f_target(video_masked) - g(f_ctx(video_ctx), positions)||^2] ## Sem Nenhum Label. ``` ## Hierarquia De Encoders Level 0: pixels -> patches -> representações locais (bordas, texturas) Level 1: patches -> regiões -> representações de objetos Level 2: regiões -> cena -> representações de relações espaciais Level 3: cena -> temporal -> representações de eventos ## Cada Nível Tem Seu Próprio Jepa: L_total = sum_l lambda_l * L_JEPA_l ## Resultado: World Model Hierárquico Multi-Escala ``` --- ## Seção Ami — Advanced Machinery Of Intelligence Paper: "A Path Towards Autonomous Machine Intelligence" (2022) ## Os 6 Módulos Do Ami ``` +----------------------------------------------------------+ | SISTEMA AMI COMPLETO | | | | +-----------+ +------------------+ | | | Perceptor | | World Model | | | | (encoders)| | (JEPA hierárquico)| | | +-----------+ +------------------+ | | | | | | v v | | +----------+ +------------------+ | | | Memory |<-->| Cost Module | | | | (epis, | | (intrínseco + | | | | semant) | | configurável) | | | +----------+ +------------------+ | | | | | +------------------+ | | | Actor (planner | | | | + executor) | | | +------------------+ | +----------------------------------------------------------+ ``` **Módulo 1 — Configurator**: Configura os outros módulos para a tarefa atual. **Módulo 2 — Perception**: Encoders sensório-motores que alimentam o world model. **Módulo 3 — World Model** (coração do sistema): ``` ## Simulação Interna: "O Que Acontece Se Eu Fizer X?" predicted_next_state = world_model(current_state, action_X) cost_predicted = cost_module(predicted_next_state) ## Escolhe Ação Que Minimiza O Custo ``` **Módulo 4 — Cost Module**: ``` ## Dois Tipos De Custo: E(s) = alpha * intrinsic_cost(s) + beta * task_cost(s) ## Task_Cost: Objetivo Configurável Por Tarefa/Humano ``` **Módulo 5 — Short-term Memory**: Buffer de estados, simulações, contexto imediato. **Módulo 6 — Actor**: - Modo reativo: ações diretas do estado atual - Modo deliberativo: simula múltiplos futuros, escolhe mínimo custo ## Ami Vs Llms | Feature | LLM | AMI | |---------|-----|-----| | Objetivo | Prever próximo token | Minimizar erro em representação | | World model | Nenhum | Módulo dedicado central | | Planning | Texto sobre planning | Planning real com simulação | | Memória | Context window (fixo) | Memória episódica atualizável | | Objetivos | Apenas treinamento | Cost module configurável | | Input | Texto | Multi-modal (video, audio, propriocepção) | | Causalidade | Correlacional | Causal (dinâmicas do mundo) | --- ## Seção Ebm — Energy-Based Models Contribuição subestimada que vai ser mais influente a longo prazo. **O problema com probabilísticos**: ``` P(x) = exp(-E(x)) / Z Z = integral exp(-E(x)) dx # intratável em alta dimensão! ``` **A solução EBM**: esquecer Z. Defina E(x) onde: - Baixa energia = configuração compatível com dados observados - Alta energia = configuração incompatível ```python class EnergyBasedModel(nn.Module): """ EBM: F(x) = energia de x P(x) ~ exp(-F(x)) / Z — mas nunca calculamos Z! Vantagem: sem partition function intratável. """ def __init__(self, latent_dim=512): super().__init__() self.energy_net = nn.Sequential( nn.Linear(latent_dim, 256), nn.SiLU(), nn.Linear(256, 128), nn.SiLU(), nn.Linear(128, 1) # escalar: energia ) def energy(self, x): return self.energy_net(x).squeeze(-1) def contrastive_loss(self, x_pos, x_neg): """ L = E[F(x_pos)] - E[F(x_neg)] + regularização Queremos: E_pos < E_neg """ E_pos = self.energy(x_pos) E_neg = self.energy(x_neg) loss = E_pos.mean() - E_neg.mean() reg = 0.1 * (E_pos.pow(2).mean() + E_neg.pow(2).mean()) return loss + reg ## Ebms Capturam Isso Naturalmente — São Sobre Compatibilidade, Não Probabilidade." ``` **JEPA como EBM no espaço de representações**: ```