Skip to main content Início Criadores beko2210 firstbrain yann-lecun-tecnico
yann-lecun-tecnico 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.
Ir para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/BEKO2210/Firstbrain --skill yann-lecun-tecnicoO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
name yann-lecun-tecnico description 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. type skill created 2026-02-27T00:00:00.000Z domain life-learning category education risk safe source community tags ["skill","life-learning","education","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 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
```python
L_V_JEPA = E[||f_target(video_masked) - g(f_ctx(video_ctx), positions)||^2 ]
Hierarquia De Encoders Level 0: pixels -> patches -> representações locais (bordas, texturas)
Level 1: patches -> regiões -> representações de objetos
Level 2: regiões -> cena -> representações de relações espaciais
Level 3: cena -> temporal -> representações de eventos
Cada Nível Tem Seu Próprio Jepa: L_total = sum_l lambda_l * L_JEPA_l
Resultado: World Model Hierárquico Multi-Escala
---
## Seção Ami — Advanced Machinery Of Intelligence
Paper: "A Path Towards Autonomous Machine Intelligence" (2022)
## Os 6 Módulos Do Ami
+----------------------------------------------------------+
| SISTEMA AMI COMPLETO |
| |
| +-----------+ +------------------+ |
| | Perceptor | | World Model | |
| | (encoders)| | (JEPA hierárquico)| |
| +-----------+ +------------------+ |
| | | |
| v v |
| +----------+ +------------------+ |
| | Memory |<-->| Cost Module | |
| | (epis, | | (intrínseco + | |
| | semant) | | configurável) | |
| +----------+ +------------------+ |
| | |
| +------------------+ |
| | Actor (planner | |
| | + executor) | |
| +------------------+ |
+----------------------------------------------------------+
**Módulo 1 — Configurator**: Configura os outros módulos para a tarefa atual.
**Módulo 2 — Perception**: Encoders sensório-motores que alimentam o world model.
**Módulo 3 — World Model** (coração do sistema):
Simulação Interna: "O Que Acontece Se Eu Fizer X?" predicted_next_state = world_model(current_state, action_X)
cost_predicted = cost_module(predicted_next_state)
Escolhe Ação Que Minimiza O Custo
**Módulo 4 — Cost Module**:
Dois Tipos De Custo: E(s) = alpha * intrinsic_cost(s) + beta * task_cost(s)
Task_Cost: Objetivo Configurável Por Tarefa/Humano
**Módulo 5 — Short-term Memory**: Buffer de estados, simulações, contexto imediato.
**Módulo 6 — Actor**:
- Modo reativo: ações diretas do estado atual
- Modo deliberativo: simula múltiplos futuros, escolhe mínimo custo
## Ami Vs Llms
| Feature | LLM | AMI |
|---------|-----|-----|
| Objetivo | Prever próximo token | Minimizar erro em representação |
| World model | Nenhum | Módulo dedicado central |
| Planning | Texto sobre planning | Planning real com simulação |
| Memória | Context window (fixo) | Memória episódica atualizável |
| Objetivos | Apenas treinamento | Cost module configurável |
| Input | Texto | Multi-modal (video, audio, propriocepção) |
| Causalidade | Correlacional | Causal (dinâmicas do mundo) |
---
## Seção Ebm — Energy-Based Models
Contribuição subestimada que vai ser mais influente a longo prazo.
**O problema com probabilísticos**:
P(x) = exp(-E(x)) / Z
Z = integral exp(-E(x)) dx # intratável em alta dimensão!
**A solução EBM**: esquecer Z. Defina E(x) onde:
- Baixa energia = configuração compatível com dados observados
- Alta energia = configuração incompatível
```python
class EnergyBasedModel(nn.Module):
"""
EBM: F(x) = energia de x
P(x) ~ exp(-F(x)) / Z — mas nunca calculamos Z!
Vantagem: sem partition function intratável.
"""
def __init__(self, latent_dim=512):
super().__init__()
self.energy_net = nn.Sequential(
nn.Linear(latent_dim, 256),
nn.SiLU(),
nn.Linear(256, 128),
nn.SiLU(),
nn.Linear(128, 1) # escalar: energia
)
def energy(self, x):
return self.energy_net(x).squeeze(-1)
def contrastive_loss(self, x_pos, x_neg):
"""
L = E[F(x_pos)] - E[F(x_neg)] + regularização
Queremos: E_pos < E_neg
"""
E_pos = self.energy(x_pos)
E_neg = self.energy(x_neg)
loss = E_pos.mean() - E_neg.mean()
reg = 0.1 * (E_pos.pow(2).mean() + E_neg.pow(2).mean())
return loss + reg
## Ebms Capturam Isso Naturalmente — São Sobre Compatibilidade, Não Probabilidade."
JEPA como EBM no espaço de representações :
E(x, y) = ||f_theta(x) - g_phi(f_theta_bar(y))||^2
## Simclr Simplificado
```python
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as T
class ProjectionHead(nn.Module):
"""MLP que projeta representações para espaço contrastivo"""
def __init__(self, in_dim=512, hidden_dim=256, out_dim=128):
super().__init__()
self.net = nn.Sequential(
nn.Linear(in_dim, hidden_dim),
nn.BatchNorm1d(hidden_dim),
nn.ReLU(inplace=True),
nn.Linear(hidden_dim, out_dim)
)
def forward(self, x):
return F.normalize(self.net(x), dim=-1)
class SimCLRLoss(nn.Module):
"""NT-Xent Loss (Chen et al. 2020)"""
def __init__(self, temperature=0.5):
super().__init__()
self.temp = temperature
def forward(self, z1, z2):
"""
z1, z2: [B, D] — duas views do mesmo batch
z1[i] e z2[i]: positive pair
Todos outros pares: negatives
"""
B = z1.size(0)
z = torch.cat([z1, z2], dim=0)
sim = torch.mm(z, z.t()) / self.temp
mask = torch.eye(2*B, device=z.device).bool()
sim.masked_fill_(mask, float('-inf'))
labels = torch.arange(B, device=z.device)
labels = torch.cat([labels + B, labels])
return F.cross_entropy(sim, labels)
def get_ssl_augmentations(size=224):
"""
As augmentações DEFINEM o que o modelo aprende a ser invariante.
Rotação -> invariância a rotação.
Crop -> invariância a posição.
"""
return T.Compose([
T.RandomResizedCrop(size, scale=(0.2, 1.0)),
T.RandomHorizontalFlip(),
T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1),
T.RandomGrayscale(p=0.2),
T.GaussianBlur(kernel_size=size//10*2+1, sigma=(0.1, 2.0)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
Lenet-5 Original Em Pytorch Moderno class LeNet5Modern (nn.Module):
"""
LeNet-5 (LeCun et al. 1998) reimplementada em PyTorch moderno.
Esta arquitetura rodou em produção no Bank of America em 1993.
~60,000 parâmetros. Mesmos princípios de modelos modernos com bilhões.
"""
def __init__ (self, num_classes=10 ):
super ().__init__()
self .features = nn.Sequential(
nn.Conv2d(1 , 6 , kernel_size=5 , padding=2 ),
nn.Tanh(),
nn.AvgPool2d(kernel_size=2 , stride=2 ),
nn.Conv2d(6 , 16 , kernel_size=5 ),
nn.Tanh(),
nn.AvgPool2d(kernel_size=2 , stride=2 ),
nn.Conv2d(16 , 120 , kernel_size=5 ),
nn.Tanh(),
)
self .classifier = nn.Sequential(
nn.Linear(120 , 84 ),
nn.Tanh(),
nn.Linear(84 , num_classes),
)
def forward (self, x ):
x = self .features(x)
x = x.view(x.size(0 ), -1 )
return self .classifier(x)
Papers Fundamentais (Lecun)
LeCun et al. (1998). "Gradient-Based Learning Applied to Document Recognition" — IEEE 86(11)
LeCun et al. (2015). "Deep Learning" — Nature 521:436-444
LeCun (2022). "A Path Towards Autonomous Machine Intelligence" — OpenReview preprint
Jepa Papers
Assran et al. (2023). "Self-Supervised Learning from Images with a JEPA" — CVPR 2023 (I-JEPA)
Bardes et al. (2024). "V-JEPA: Self-Supervised Learning of Video Representations" — NeurIPS 2023
LeCun (2016). "Predictive Learning" — NIPS Keynote (The Cake Analogy)
Ssl Relevantes
He et al. (2022). "Masked Autoencoders Are Scalable Vision Learners" — CVPR 2022
Chen et al. (2020). "A Simple Framework for Contrastive Learning" (SimCLR) — ICML 2020
Grill et al. (2020). "Bootstrap Your Own Latent" (BYOL) — NeurIPS 2020
Energy-Based Models
LeCun et al. (2006). "A Tutorial on Energy-Based Learning" — ICLR Workshop
LeCun (2021). "Energy-Based Models for Autonomous and Predictive Learning" — ICLR Keynote
Best Practices
Provide clear, specific context about your project and requirements
Review all suggestions before applying them to production code
Combine with other complementary skills for comprehensive analysis
Common Pitfalls
Using this skill for tasks outside its domain expertise
Applying recommendations without understanding your specific context
Not providing enough project context for accurate analysis
Related Skills
yann-lecun - Complementary skill for enhanced analysisyann-lecun-debate - Complementary skill for enhanced analysisyann-lecun-filosofia - Complementary skill for enhanced analysis
Connections
Domain: [[Leben & Lernen]]Kategorie: [[Bildung & Wissen]]Navigation: [[Skills Uebersicht]], [[Home]] 