关于UCloud(优刻得)旗下的compshare算力共享平台
UCloud(优刻得)是中国知名的中立云计算服务商，科创板上市，中国云计算第一股。
Compshare GPU算力平台隶属于UCloud，专注于提供高性价4090算力资源，配备独立IP，支持按时、按天、按月灵活计费，支持github、huggingface访问加速。
使用下方链接注册可获得20元算力金，免费体验10小时4090云算力
https://www.compshare.cn/?ytag=GPU_lovelyyoshino_Lcsdn_csdn_display。
1. 项目介绍
V-JEPA 2（Video Joint-Embedding Predictive Architecture 2） 是Meta AI在世界模型构建领域的重大突破，这是一个能够像人类一样理解、预测和规划的自监督视频模型。正如官方论文所述，该模型建立在深刻的认知学习理论基础之上：人类通过整合低级感官输入来表示和预测未来状态，从而学习世界的内部模型。
V-JEPA 2将这一理论转化为实际的技术实现，通过分析超过100万小时的互联网视频数据，建立起对物理世界的直觉理解。核心创新在于联合嵌入预测架构（JEPA），它通过在学习到的表示空间中进行预测，而非像传统方法那样在像素空间中操作。这种设计使得模型能够专注于学习物体轨迹、因果关系等可预测的物理规律，而不是纠结于无关的细节噪声。主要优势包括：
- 无需标注训练：通过自监督学习方式，在超过100万小时的视频数据上进行训练
- 世界模型构建：学会了"球掉下桌子不会消失"等从婴幼儿就具备的直观物理常识
- 零样本规划 ：能够在未见过的环境中预测一系列合理步骤并逐步实现目标
该模型在多个基准测试中取得了突破性成果：在Something-Something v2上达到77.3%的top-1准确率，在Epic-Kitchens-100人类动作预期任务上达到39.7的recall-at-5。更令人瞩目的是，V-JEPA 2-AC（Action-Conditioned）变体仅使用62小时未标注机器人视频进行微调，就实现了零样本机器人操作规划，在到达、抓取和拾取-放置等任务中取得了65-80%的成功率，执行效率比传统方法提升15倍。原始JEPA项目的完整代码实现可以在https://github.com/facebookresearch/jepa 找到，该仓库包含了核心算法的参考实现和详细的文档说明。V-JEPA 2的最新版本及其增强功能则可以在https://github.com/facebookresearch/vjepa2 获取，这里提供了更加优化的模型结构和训练脚本。对于理论背景和技术原理的深入理解，建议仔细阅读Meta AI发布的官方论文https://arxiv.org/pdf/2506.09985，该论文详细阐述了V-JEPA 2的设计思路、实验验证和性能分析。
这里最近受到优刻得的使用邀请，正好解决了我在大模型和具身智能行业对GPU的使用需求，现在优刻得正在着力于发展具身服务。作为UCloud云计算旗下的Compshare的GPU算力云平台。他们提供高性价比的24G的4090，按时收费每卡1.88元；此外48G的4090 ，也即将上线5090 GPU，并附带200G的免费磁盘空间。暂时已经满足我的使用需求了，同时支持访问加速，独立IP等功能，能够更快的完成项目搭建。此外对于低性能的还有3080TI使用只需要0.88元，已经吊打市面上主流的云服务器了。这里我们也提供了镜像，作者在compshare平台制作了这个镜像，可以直接一键部署：https://console.compshare.cn/light-gpu/resources/create?ImageId=11ee932d-943f-41f3-a5f9-389cb9b8b554&ImageType=Community&VersionName=v1.0&ImageType=Community&ytag=GPU_lovelyyoshino_Lcsdn_csdn_display
2. 安装配置
2.1 环境要求
- Python 3.11+
- PyTorch 2.0+
- CUDA 11.8+（推荐）
- 至少16GB GPU内存（ViT-L模型）
2.2 快速安装
bash
# 克隆项目
git clone https://github.com/facebookresearch/vjepa2.git
cd jepa
# 创建虚拟环境
conda create -n vjepa python=3.11
conda activate vjepa
# 安装PyTorch (根据CUDA版本选择)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
# 安装项目依赖
pip install -r requirements.txt
# 安装项目
pip install -e .
3. 核心代码架构与创新详解
3.1 Vision Transformer编码器 - 时空数据处理的创新
V-JEPA 2的编码器是整个架构的基础，其最大创新在于统一处理图像和视频数据的设计。在src/models/vision_transformer.py中，VisionTransformer类实现了这一关键功能：
python
class VisionTransformer(nn.Module):
"""Vision Transformer - V-JEPA 2的核心编码器"""
def __init__(
self,
img_size=(224, 224), # 输入图像尺寸
patch_size=16, # 补丁大小
num_frames=1, # 视频帧数
tubelet_size=2, # 时间维度补丁大小
in_chans=3, # 输入通道数
embed_dim=768, # 嵌入维度
depth=12, # Transformer层数
num_heads=12, # 注意力头数
uniform_power=False, # 位置编码时空平衡
use_rope=False, # 是否使用旋转位置编码
use_activation_checkpointing=False, # 激活检查点优化
**kwargs
):
super().__init__()
self.num_features = self.embed_dim = embed_dim
self.num_heads = num_heads
# 处理输入尺寸
if type(img_size) is int:
img_size = (img_size, img_size)
self.img_height, self.img_width = img_size
self.patch_size = patch_size
self.num_frames = num_frames
self.tubelet_size = tubelet_size
self.is_video = num_frames > 1 # 判断是否为视频输入
self.use_activation_checkpointing = use_activation_checkpointing
# 随机深度衰减规则
dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
# 核心创新1：自适应的补丁嵌入
if self.is_video:
# 3D补丁嵌入 - 处理时空数据
self.patch_embed = PatchEmbed3D(
patch_size=patch_size,
tubelet_size=tubelet_size,
in_chans=in_chans,
embed_dim=embed_dim
)
# 计算3D补丁数量：时间×高度×宽度
self.num_patches = (
(num_frames // tubelet_size)
* (img_size[0] // patch_size)
* (img_size[1] // patch_size)
)
else:
# 2D补丁嵌入 - 处理图像数据
self.patch_embed = PatchEmbed(
patch_size=patch_size,
in_chans=in_chans,
embed_dim=embed_dim
)
self.num_patches = (img_size[0] // patch_size) * (img_size[1] // patch_size)
# 核心创新2：时空位置编码
self.uniform_power = uniform_power
self.use_rope = use_rope
if self.use_rope:
self.pos_embed = None # 使用旋转位置编码时不需要固定位置编码
else:
# 使用固定的正弦-余弦位置编码
self.pos_embed = nn.Parameter(
torch.zeros(1, self.num_patches, embed_dim),
requires_grad=False
)
# Transformer块 - 支持多种优化策略
self.blocks = nn.ModuleList([
Block(
use_rope=use_rope,
grid_size=img_size[0] // patch_size,
grid_depth=num_frames // tubelet_size,
dim=embed_dim,
num_heads=num_heads,
mlp_ratio=4.0,
qkv_bias=True,
use_sdpa=True, # 使用缩放点积注意力
drop_path=dpr[i],
) for i in range(depth)
])
self.norm = nn.LayerNorm(embed_dim)
# 权重初始化
if self.pos_embed is not None:
self._init_pos_embed(self.pos_embed.data)
self.apply(self._init_weights)
self._rescale_blocks()这一设计的关键创新体现在三个方面。首先是统一架构设计，通过is_video标志位实现了单一类处理图像和视频数据的能力，避免了维护两套代码的复杂性，同时确保了图像和视频处理逻辑的一致性和可维护性。其次是3D时空补丁嵌入机制，PatchEmbed3D将视频分解为时空"tubelets"，每个tubelet包含tubelet_size个连续帧的同一空间位置的补丁，这种设计巧妙地捕获了时空的局部相关性，为模型提供了更丰富的时序信息。最后是自适应位置编码系统，位置编码根据输入类型自动调整维度，为时空数据提供完整的坐标信息，确保模型能够准确理解每个补丁在时空中的具体位置。
3.2 位置编码系统 - 时空坐标的精确表示
位置编码的初始化展现了V-JEPA 2对时空数据处理的深度思考：
python
def _init_pos_embed(self, pos_embed):
"""初始化位置编码 - 支持2D和3D
Args:
pos_embed: 位置编码参数张量
"""
embed_dim = pos_embed.size(-1)
grid_size = self.img_height // self.patch_size # 空间网格大小
if self.is_video:
# 3D位置编码 - 为视频数据提供时空坐标
grid_depth = self.num_frames // self.tubelet_size # 时间网格大小
sincos = get_3d_sincos_pos_embed(
embed_dim,
grid_size, # 空间网格大小
grid_depth, # 时间网格大小
cls_token=False, # 不使用分类标记
uniform_power=self.uniform_power # 平衡时空维度权重
)
else:
# 2D位置编码 - 为图像数据提供空间坐标
sincos = get_2d_sincos_pos_embed(
embed_dim,
grid_size,
cls_token=False
)
# 将生成的位置编码复制到参数中
pos_embed.copy_(torch.from_numpy(sincos).float().unsqueeze(0))3.3 前向传播 - 掩码处理的核心逻辑
python
def forward(self, x, masks=None):
"""
前向传播 - 支持掩码的时空特征提取
Args:
x: 输入张量 [B, C, T, H, W] (视频) 或 [B, C, H, W] (图像)
masks: 掩码索引列表，用于自监督学习
Returns:
特征张量 [B, N, D] N=保留的补丁数量, D=特征维度
"""
# 确保掩码是列表格式
if masks is not None and not isinstance(masks, list):
masks = [masks]
# 1. 提取输入维度信息
if x.ndim == 4:
# 图像输入：[B, C, H, W]
_, _, H, W = x.shape
T = 1
elif x.ndim == 5:
# 视频输入：[B, C, T, H, W]
_, _, T, H, W = x.shape
T = T // self.tubelet_size
H_patches = H // self.patch_size
W_patches = W // self.patch_size
# 2. 补丁嵌入 + 位置编码
if not self.use_rope:
# 使用固定位置编码
pos_embed = self.interpolate_pos_encoding(x, self.pos_embed)
x = self.patch_embed(x) # [B, N, D]
x += pos_embed
else:
# 使用旋转位置编码（在注意力层中处理）
x = self.patch_embed(x)
# 3. 核心创新：掩码应用
if masks is not None:
x = apply_masks(x, masks) # 移除被掩盖的补丁
masks = torch.cat(masks, dim=0)
# 4. Transformer前向传播
for i, blk in enumerate(self.blocks):
if self.use_activation_checkpointing:
# 使用梯度检查点节省内存
x = torch.utils.checkpoint.checkpoint(
blk, x, masks, None,
T=T, H_patches=H_patches, W_patches=W_patches,
use_reentrant=False
)
else:
x = blk(x, mask=masks, attn_mask=None,
T=T, H_patches=H_patches, W_patches=W_patches)
# 5. 输出标准化
if self.norm is not None:
x = self.norm(x)
return x3.4 预测器模块 - JEPA架构的核心创新
预测器是V-JEPA 2最关键的创新组件，实现了在表示空间而非像素空间的预测：
python
class VisionTransformerPredictor(nn.Module):
"""V-JEPA 2 预测器 - 在表示空间进行预测的核心模块"""
def __init__(
self,
img_size=(224, 224), # 输入图像尺寸
patch_size=16, # 补丁大小
num_frames=1, # 视频帧数
tubelet_size=2, # 时间维度补丁大小
embed_dim=768, # 编码器输出维度
predictor_embed_dim=384, # 预测器内部维度（降维）
depth=6, # 预测器层数
num_heads=12, # 注意力头数
use_mask_tokens=False, # 是否使用掩码令牌
num_mask_tokens=2, # 掩码令牌数量
use_rope=False, # 是否使用旋转位置编码
**kwargs
):
super().__init__()
# 核心创新1：维度映射 - 降维处理
self.predictor_embed = nn.Linear(embed_dim, predictor_embed_dim, bias=True)
# 核心创新2：掩码令牌机制
self.mask_tokens = None
self.num_mask_tokens = 0
if use_mask_tokens:
self.num_mask_tokens = num_mask_tokens
self.mask_tokens = nn.ParameterList([
nn.Parameter(torch.zeros(1, 1, predictor_embed_dim))
for _ in range(num_mask_tokens)
])
# 处理输入尺寸
if type(img_size) is int:
img_size = (img_size, img_size)
self.img_height, self.img_width = img_size
self.patch_size = patch_size
self.num_frames = num_frames
self.tubelet_size = tubelet_size
self.is_video = num_frames > 1
# 计算网格信息
self.grid_height = img_size[0] // self.patch_size
self.grid_width = img_size[1] // self.patch_size
self.grid_depth = num_frames // self.tubelet_size
# 计算补丁总数
if self.is_video:
self.num_patches = (
(num_frames // tubelet_size)
* (img_size[0] // patch_size)
* (img_size[1] // patch_size)
)
else:
self.num_patches = (img_size[0] // patch_size) * (img_size[1] // patch_size)
# 位置编码（预测器专用）
self.use_rope = use_rope
self.predictor_pos_embed = None
if not use_rope:
self.predictor_pos_embed = nn.Parameter(
torch.zeros(1, self.num_patches, predictor_embed_dim),
requires_grad=False
)
# 预测器Transformer块
self.predictor_blocks = nn.ModuleList([
Block(
use_rope=use_rope,
grid_size=self.grid_height,
grid_depth=self.grid_depth,
dim=predictor_embed_dim,
num_heads=num_heads,
mlp_ratio=4.0,
qkv_bias=True,
) for _ in range(depth)
])
# 输出投影 - 升维回原始空间
self.predictor_norm = nn.LayerNorm(predictor_embed_dim)
self.predictor_proj = nn.Linear(predictor_embed_dim, embed_dim, bias=True)
# 权重初始化
if self.predictor_pos_embed is not None:
self._init_pos_embed(self.predictor_pos_embed.data)
self.apply(self._init_weights)
self._rescale_blocks()- 降维-升维设计：预测器在较低维度空间操作，提高效率同时迫使学习抽象表示
- 掩码令牌机制：可学习的查询向量，明确指示需要预测的位置
- 独立位置编码：预测器有自己的位置编码系统，适应预测任务的特殊需求
3.5 预测器前向传播 - 上下文整合与预测
python
def forward(self, x, masks_x, masks_y, mask_index=1, has_cls=False):
"""
预测器前向传播 - JEPA的核心预测逻辑
Args:
x: 上下文特征 [B_ctxt, N_ctxt, D]
masks_x: 上下文掩码索引（要保留的区域）
masks_y: 目标掩码索引（要预测的区域）
mask_index: 使用哪个掩码令牌
has_cls: 是否包含分类令牌
Returns:
predictions: 预测特征 [B, N_pred, embed_dim]
"""
# 确保掩码是列表格式
assert (masks_x is not None) and (masks_y is not None), \
"Cannot run predictor without mask indices"
if not isinstance(masks_x, list):
masks_x = [masks_x]
if not isinstance(masks_y, list):
masks_y = [masks_y]
# 批量大小
B = len(x) // len(masks_x)
# 1. 上下文特征映射到预测器维度
x = self.predictor_embed(x) # [B_ctxt, N_ctxt, predictor_dim]
# 处理分类令牌（如果存在）
if has_cls:
x_cls = x[:, :1, :] # 分离分类令牌
x = x[:, 1:, :] # 移除分类令牌
_, N_ctxt, D = x.shape
# 2. 添加上下文位置编码
if not self.use_rope:
x_pos_embed = self.predictor_pos_embed.repeat(B, 1, 1)
x += apply_masks(x_pos_embed, masks_x)
# 3. 核心创新：掩码令牌处理
mask_index = mask_index % self.num_mask_tokens
pred_tokens = self.mask_tokens[mask_index] # 获取对应的掩码令牌
# 扩展掩码令牌到所有补丁位置，然后应用目标掩码
pred_tokens = pred_tokens.repeat(B, self.num_patches, 1)
pred_tokens = apply_masks(pred_tokens, masks_y)
# 添加预测位置的位置编码
if not self.use_rope:
pos_embs = self.predictor_pos_embed.repeat(B, 1, 1)
pos_embs = apply_masks(pos_embs, masks_y)
pos_embs = repeat_interleave_batch(pos_embs, B, repeat=len(masks_x))
pred_tokens += pos_embs
# 4. 拼接上下文和预测令牌
x = x.repeat(len(masks_x), 1, 1) # 重复上下文特征以匹配批量
x = torch.cat([x, pred_tokens], dim=1)
# 5. 准备掩码信息用于注意力计算
masks_x = torch.cat(masks_x, dim=0)
masks_y = torch.cat(masks_y, dim=0)
masks = torch.cat([masks_x, masks_y], dim=1)
# 按位置索引排序，确保令牌顺序正确
argsort = torch.argsort(masks, dim=1)
# 6. Transformer预测处理
for blk in self.predictor_blocks:
x = blk(x) # 预测器不需要位置信息，因为已经融入位置编码
x = self.predictor_norm(x)
# 7. 提取预测结果并投影回原维度
# 根据排序恢复原始顺序，然后提取预测部分
x = torch.gather(x, dim=1, index=argsort.unsqueeze(-1).expand(-1, -1, x.size(-1)))
predictions = x[:, N_ctxt:] # 只取预测部分
predictions = self.predictor_proj(predictions) # 投影回编码器维度
return predictions3.6 掩码策略实现 - 多块掩码的创新设计
V-JEPA 2的成功很大程度上归功于其创新的掩码策略，实现在src/masks/目录中：
python
def apply_masks(x, masks, concat=True):
"""
应用掩码到输入张量 - 核心掩码处理函数
Args:
x: 输入张量 [B, N, D] - B=批量大小, N=补丁数量, D=特征维度
masks: 掩码索引列表，包含要保留的补丁索引
concat: 是否连接结果
Returns:
masked_x: 掩码后的张量列表或连接的张量
"""
all_x = []
for m in masks:
# 使用gather操作根据掩码索引提取对应的特征
mask_keep = m.unsqueeze(-1).repeat(1, 1, x.size(-1)) # 扩展掩码维度
all_x += [torch.gather(x, dim=1, index=mask_keep)] # 提取被保留的补丁
if not concat:
return all_x
return torch.cat(all_x, dim=0) # 沿批量维度连接
class _MaskGenerator(object):
"""
多块掩码生成器 - V-JEPA 2的关键创新
生成连续的3D时空块作为掩码，而非传统的随机点掩码
"""
def __init__(
self,
crop_size=(224, 224), # 裁剪尺寸
num_frames=16, # 视频帧数
spatial_patch_size=(16, 16), # 空间补丁大小
temporal_patch_size=2, # 时间补丁大小
spatial_pred_mask_scale=(0.2, 0.8), # 空间掩码比例范围
temporal_pred_mask_scale=(1.0, 1.0), # 时间掩码比例范围
aspect_ratio=(0.3, 3.0), # 宽高比范围
npred=1, # 预测块数量
max_context_frames_ratio=1.0, # 最大上下文帧比例
max_keep=None, # 最大保留补丁数
**kwargs
):
super(_MaskGenerator, self).__init__()
# 标准化输入尺寸
if not isinstance(crop_size, tuple):
crop_size = (crop_size,) * 2
if not isinstance(spatial_patch_size, tuple):
spatial_patch_size = (spatial_patch_size,) * 2
self.crop_size = crop_size
# 计算网格大小
self.height = crop_size[0] // spatial_patch_size[0]
self.width = crop_size[1] // spatial_patch_size[1]
self.duration = num_frames // temporal_patch_size
# 保存参数
self.spatial_patch_size = spatial_patch_size
self.temporal_patch_size = temporal_patch_size
self.aspect_ratio = aspect_ratio
self.spatial_pred_mask_scale = spatial_pred_mask_scale
self.temporal_pred_mask_scale = temporal_pred_mask_scale
self.npred = npred
# 上下文约束
self.max_context_duration = max(
1, int(self.duration * max_context_frames_ratio)
)
self.max_keep = max_keep
# 全局计数器（用于多进程同步）
self._itr_counter = Value("i", -1)
def _sample_block_size(self, generator, temporal_scale, spatial_scale, aspect_ratio_scale):
"""
采样块大小 - 根据给定的比例范围随机生成掩码块尺寸
Args:
generator: 随机数生成器
temporal_scale: 时间比例范围
spatial_scale: 空间比例范围
aspect_ratio_scale: 宽高比范围
Returns:
(t, h, w): 块的时间、高度、宽度尺寸
"""
# 1. 采样时间维度掩码比例
_rand = torch.rand(1, generator=generator).item()
min_t, max_t = temporal_scale
temporal_mask_scale = min_t + _rand * (max_t - min_t)
t = max(1, int(self.duration * temporal_mask_scale))
# 2. 采样空间维度掩码比例
_rand = torch.rand(1, generator=generator).item()
min_s, max_s = spatial_scale
spatial_mask_scale = min_s + _rand * (max_s - min_s)
spatial_num_keep = int(self.height * self.width * spatial_mask_scale)
# 3. 采样块的宽高比
_rand = torch.rand(1, generator=generator).item()
min_ar, max_ar = aspect_ratio_scale
aspect_ratio = min_ar + _rand * (max_ar - min_ar)
# 4. 根据比例和宽高比计算块的高度和宽度
h = int(round(math.sqrt(spatial_num_keep * aspect_ratio)))
w = int(round(math.sqrt(spatial_num_keep / aspect_ratio)))
h = min(h, self.height)
w = min(w, self.width)
return (t, h, w)
def _sample_block_mask(self, b_size):
"""
生成单个块掩码
Args:
b_size: 块尺寸 (t, h, w)
Returns:
mask: 3D掩码张量，0表示被掩盖，1表示保留
"""
t, h, w = b_size
# 随机选择块的起始位置
top = torch.randint(0, self.height - h + 1, (1,))
left = torch.randint(0, self.width - w + 1, (1,))
start = torch.randint(0, self.duration - t + 1, (1,))
# 创建掩码：默认全部保留(1)，被掩盖区域设为0
mask = torch.ones((self.duration, self.height, self.width), dtype=torch.int32)
mask[start:start + t, top:top + h, left:left + w] = 0
# 上下文掩码只覆盖前X帧（X=max_context_duration）
if self.max_context_duration < self.duration:
mask[self.max_context_duration:, :, :] = 0
return maskV-JEPA 2的掩码策略在四个关键方面实现了突破性创新。首先是3D连续块设计，不同于传统的随机点掩码，该方法生成连续的时空区域作为掩码，这种设计更好地符合视频数据的自然结构特征，能够模拟真实世界中物体和场景的连续性变化。其次是自适应大小机制，掩码块的大小和形状会随机变化，这种多样性增加了训练过程中的挑战性，迫使模型学习更加鲁棒的表示。第三是时空分离控制，算法分别控制时间和空间维度的掩码比例，允许模型独立学习时间动态和空间结构，避免了简单混合可能带来的偏向性问题。最后是互补设计原则，上下文和目标区域严格不重叠，这种设计确保了预测任务的有效性，避免了信息泄露，同时最大化了自监督学习的挑战性。
3.7 快速使用示例
3.7.1 使用torch.hub加载预训练模型
V-JEPA 2提供了通过PyTorch Hub的便捷加载方式，这是目前推荐的使用方法，无需手动下载代码或配置复杂的环境。通过torch.hub.load可以直接获取预训练的编码器和预测器，大大简化了使用流程。
python
import torch
import numpy as np
# 步骤1：通过PyTorch Hub加载预训练模型
# 可选模型: vjepa2_vit_large, vjepa2_vit_huge, vjepa2_vit_giant, vjepa2_vit_giant_384
encoder = torch.hub.load('facebookresearch/vjepa2', 'vjepa2_vit_giant')
processor = torch.hub.load('facebookresearch/vjepa2', 'vjepa2_preprocessor')
# 步骤2：加载动作条件预测器（用于机器人应用）
vjepa2_encoder, vjepa2_ac_predictor = torch.hub.load('facebookresearch/vjepa2', 'vjepa2_ac_vit_giant')
# 步骤3：准备视频数据（添加输入验证和转换）
video_tensor = torch.randn(1, 64, 3, 256, 256) # [B, T, C, H, W]
# 确保C=3，如果形状不正确，进行转换
if video_tensor.shape[2] != 3: # 检查通道数
video_tensor = torch.cat([video_tensor] * 3, dim=2)[:1, :64, :3, :, :] # 强制转换为3通道
# 步骤4：使用预处理器处理视频数据
inputs = processor(video_tensor)
# 步骤5：特征提取
with torch.no_grad():
# 获取视频特征
features = encoder(**inputs)
print(f"Encoder output shape: {features.shape}")
print("V-JEPA 2模型加载和推理完成")
3.7.2 使用HuggingFace Transformers
V-JEPA 2也支持通过HuggingFace Transformers库使用，这提供了更标准化的API接口和更好的生态系统集成。
python
from transformers import AutoVideoProcessor, AutoModel
import torch
import numpy as np
# 步骤1：从HuggingFace加载模型和处理器
hf_repo = "facebook/vjepa2-vitg-fpc64-256"
# 其他可选模型：
# facebook/vjepa2-vitl-fpc64-256
# facebook/vjepa2-vith-fpc64-256
# facebook/vjepa2-vitg-fpc64-256
# facebook/vjepa2-vitg-fpc64-384
model = AutoModel.from_pretrained(hf_repo)
processor = AutoVideoProcessor.from_pretrained(hf_repo)
# 步骤2：准备视频数据（64帧，256x256分辨率）
video = np.random.rand(64, 256, 256, 3).astype(np.float32) # T x H x W x C
# 步骤3：预处理视频
inputs = processor(video, return_tensors="pt").to(model.device)
# 步骤4：模型推理
with torch.no_grad():
outputs = model(**inputs)
# V-JEPA 2编码器输出
encoder_features = outputs.last_hidden_state
print(f"Encoder features shape: {encoder_features.shape}")
# V-JEPA 2预测器输出
if hasattr(outputs, 'predictor_output'):
predictor_features = outputs.predictor_output.last_hidden_state
print(f"Predictor features shape: {predictor_features.shape}")
print("HuggingFace Transformers推理完成")
3.7.3 视频分类应用示例
对于已经在特定数据集上微调的模型，可以直接用于视频分类任务，这展示了V-JEPA 2在下游应用中的强大能力。
python
from transformers import AutoVideoProcessor, AutoModelForVideoClassification
import torch
import numpy as np
# 步骤1：加载在Something-Something-V2上微调的分类模型
model = AutoModelForVideoClassification.from_pretrained("facebook/vjepa2-vitl-fpc16-256-ssv2")
processor = AutoVideoProcessor.from_pretrained("facebook/vjepa2-vitl-fpc16-256-ssv2")
# 步骤2：准备视频数据（16帧用于分类）
video = np.random.rand(16, 256, 256, 3).astype(np.float32)
# 步骤3：预处理和推理
inputs = processor(video, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
logits = outputs.logits
# 步骤4：获取预测结果
top5_indices = logits.topk(5).indices[0]
top5_probs = torch.softmax(logits, dim=-1).topk(5).values[0]
print("Top 5 预测类别:")
for idx, prob in zip(top5_indices, top5_probs):
class_name = model.config.id2label[idx.item()]
print(f" - {class_name}: {prob:.3f}")
这些使用示例展现了V-JEPA 2在实际应用中的便捷性和强大功能，如果想学习官方的例子可以在vjepa2/notebooks/vjepa2_demo.py中。
该脚本假定已下载模型检查点，因此您需要下载模型权重并更新脚本中的相应路径。例如：
bash
wget https://dl.fbaipublicfiles.com/vjepa2/vitg-384.pt -P /models/
wget https://dl.fbaipublicfiles.com/vjepa2/evals/ssv2-vitg-384-64x2x3.pt -P /models/
# Then update your model paths in vjepa2_demo.py.
pt_model_path = /models/vitg-384.pt
classifier_model_path = /models/ssv2-vitg-384-64x2x3.pt
# Then run the script (assumes your machine has a GPU)
python notebooks/vjepa2_demo.py
从PyTorch Hub的一键加载到HuggingFace生态系统的无缝集成，再到具体的视频分类应用，每个示例都体现了该架构的工程化成熟度和实用价值。V-JEPA 2的核心优势在于其多层次的可用性：研究人员可以通过torch.hub快速获取预训练模型进行特征提取，开发者可以利用HuggingFace标准化接口轻松集成到现有项目中，而应用开发者则可以直接使用微调后的分类模型解决实际业务问题。这种从基础研究到产业应用的完整链条体现了V-JEPA 2不仅在技术创新上的突破，更在工程实现和生态建设方面的成功，为自监督视频理解技术的广泛应用奠定了坚实基础。
4. 总结
V-JEPA 2的意义远不止于技术指标的提升。它代表了机器学习向真正智能的重要跨越：从被动的模式识别到主动的世界理解。这个模型第一次让机器具备了"观察-理解-行动"的闭环能力，无需明确指令，仅凭模糊的视觉目标就能推演出合理的行动路径，像人类学徒一样在世界中"试着做"。
这种突破为通用人工智能（AGI）的实现提供了新的路径：不是通过更大的数据集和更复杂的网络，而是通过更好地模拟人类的学习机制------在互动中理解世界，在预测中积累智慧。V-JEPA 2不仅是一个技术突破，更是人工智能向真正理解世界迈出的关键一步。