diff --git a/.gitattributes b/.gitattributes index c088338c3e1d279a52aaddc52b1f03283b588b2f..ed1627142858821e5683c2e53416efbfc28ee767 100644 --- a/.gitattributes +++ b/.gitattributes @@ -59,3 +59,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.mp4 filter=lfs diff=lfs merge=lfs -text *.webm filter=lfs diff=lfs merge=lfs -text video_gen_14d/models/Wan2.1-VACE-1.3B/google/umt5-xxl/tokenizer.json filter=lfs diff=lfs merge=lfs -text +video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/lvis/annotations/lvis_v1_minival_inserted_image_name.json filter=lfs diff=lfs merge=lfs -text +video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lvis/lvis_v1_minival_inserted_image_name.json filter=lfs diff=lfs merge=lfs -text +video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/coco/lvis/lvis_v1_minival_inserted_image_name.json filter=lfs diff=lfs merge=lfs -text diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/eva_vit.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/eva_vit.py new file mode 100644 index 0000000000000000000000000000000000000000..d2330c322677b860c0c04c3d153b99caaf4f6a7a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/eva_vit.py @@ -0,0 +1,856 @@ +""" +# Adapted from https://github.com/baaivision/EVA/tree/master/EVA-CLIP +""" + +from math import pi +import torch +from torch import nn +from einops import rearrange, repeat +import logging +from llava.utils import rank0_print + + +def broadcat(tensors, dim=-1): + num_tensors = len(tensors) + shape_lens = set(list(map(lambda t: len(t.shape), tensors))) + assert len(shape_lens) == 1, "tensors must all have the same number of dimensions" + shape_len = list(shape_lens)[0] + dim = (dim + shape_len) if dim < 0 else dim + dims = list(zip(*map(lambda t: list(t.shape), tensors))) + expandable_dims = [(i, val) for i, val in enumerate(dims) if i != dim] + assert all([*map(lambda t: len(set(t[1])) <= 2, expandable_dims)]), "invalid dimensions for broadcastable concatentation" + max_dims = list(map(lambda t: (t[0], max(t[1])), expandable_dims)) + expanded_dims = list(map(lambda t: (t[0], (t[1],) * num_tensors), max_dims)) + expanded_dims.insert(dim, (dim, dims[dim])) + expandable_shapes = list(zip(*map(lambda t: t[1], expanded_dims))) + tensors = list(map(lambda t: t[0].expand(*t[1]), zip(tensors, expandable_shapes))) + return torch.cat(tensors, dim=dim) + + +def rotate_half(x): + x = rearrange(x, "... (d r) -> ... d r", r=2) + x1, x2 = x.unbind(dim=-1) + x = torch.stack((-x2, x1), dim=-1) + return rearrange(x, "... d r -> ... (d r)") + + +class VisionRotaryEmbeddingFast(nn.Module): + def __init__(self, dim, pt_seq_len, ft_seq_len=None, custom_freqs=None, freqs_for="lang", theta=10000, max_freq=10, num_freqs=1, patch_dropout=0.0): + super().__init__() + if custom_freqs: + freqs = custom_freqs + elif freqs_for == "lang": + freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim)) + elif freqs_for == "pixel": + freqs = torch.linspace(1.0, max_freq / 2, dim // 2) * pi + elif freqs_for == "constant": + freqs = torch.ones(num_freqs).float() + else: + raise ValueError(f"unknown modality {freqs_for}") + + if ft_seq_len is None: + ft_seq_len = pt_seq_len + t = torch.arange(ft_seq_len) / ft_seq_len * pt_seq_len + + freqs = torch.einsum("..., f -> ... f", t, freqs) + freqs = repeat(freqs, "... n -> ... (n r)", r=2) + freqs = broadcat((freqs[:, None, :], freqs[None, :, :]), dim=-1) + + freqs_cos = freqs.cos().view(-1, freqs.shape[-1]) + freqs_sin = freqs.sin().view(-1, freqs.shape[-1]) + + self.patch_dropout = patch_dropout + + self.register_buffer("freqs_cos", freqs_cos) + self.register_buffer("freqs_sin", freqs_sin) + + logging.info(f"Shape of rope freq: {self.freqs_cos.shape}") + + def forward(self, t, patch_indices_keep=None): + if patch_indices_keep is not None: + batch = t.size()[0] + batch_indices = torch.arange(batch) + batch_indices = batch_indices[..., None] + + freqs_cos = repeat(self.freqs_cos, "i j -> n i m j", n=t.shape[0], m=t.shape[1]) + freqs_sin = repeat(self.freqs_sin, "i j -> n i m j", n=t.shape[0], m=t.shape[1]) + + freqs_cos = freqs_cos[batch_indices, patch_indices_keep] + freqs_cos = rearrange(freqs_cos, "n i m j -> n m i j") + freqs_sin = freqs_sin[batch_indices, patch_indices_keep] + freqs_sin = rearrange(freqs_sin, "n i m j -> n m i j") + + return t * freqs_cos + rotate_half(t) * freqs_sin + + return t * self.freqs_cos + rotate_half(t) * self.freqs_sin + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm (with cast back to input dtype).""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + x = F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps) + return x.to(orig_type) + + +class PatchDropout(nn.Module): + """ + https://arxiv.org/abs/2212.00794 + """ + + def __init__(self, prob, exclude_first_token=True): + super().__init__() + assert 0 <= prob < 1.0 + self.prob = prob + self.exclude_first_token = exclude_first_token # exclude CLS token + logging.info(f"os.getenv('RoPE')={os.getenv('RoPE')}") + + def forward(self, x): + if not self.training or self.prob == 0.0: + return x + + if self.exclude_first_token: + cls_tokens, x = x[:, :1], x[:, 1:] + else: + cls_tokens = torch.jit.annotate(torch.Tensor, x[:, :1]) + + batch = x.size()[0] + num_tokens = x.size()[1] + + batch_indices = torch.arange(batch) + batch_indices = batch_indices[..., None] + + keep_prob = 1 - self.prob + num_patches_keep = max(1, int(num_tokens * keep_prob)) + + rand = torch.randn(batch, num_tokens) + patch_indices_keep = rand.topk(num_patches_keep, dim=-1).indices + + x = x[batch_indices, patch_indices_keep] + + if self.exclude_first_token: + x = torch.cat((cls_tokens, x), dim=1) + + if self.training and os.getenv("RoPE") == "1": + return x, patch_indices_keep + + return x + + +# -------------------------------------------------------- +# Adapted from https://github.com/microsoft/unilm/tree/master/beit +# -------------------------------------------------------- +import math +import os +import torch.nn as nn +import torch.nn.functional as F + +try: + from timm.models.layers import drop_path, to_2tuple, trunc_normal_ +except: + from timm.layers import drop_path, to_2tuple, trunc_normal_ + +if os.getenv("ENV_TYPE") == "deepspeed": + try: + from deepspeed.runtime.activation_checkpointing.checkpointing import checkpoint + except: + from torch.utils.checkpoint import checkpoint +else: + from torch.utils.checkpoint import checkpoint + +try: + import xformers.ops as xops +except ImportError: + xops = None + # print("Please 'pip install xformers'") + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).""" + + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + def extra_repr(self) -> str: + return "p={}".format(self.drop_prob) + + +class Mlp(nn.Module): + def __init__( + self, + in_features, + hidden_features=None, + out_features=None, + act_layer=nn.GELU, + norm_layer=nn.LayerNorm, + drop=0.0, + subln=False, + ): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + + self.ffn_ln = norm_layer(hidden_features) if subln else nn.Identity() + + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + # x = self.drop(x) + # commit this for the orignal BERT implement + x = self.ffn_ln(x) + + x = self.fc2(x) + x = self.drop(x) + return x + + +class SwiGLU(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.SiLU, drop=0.0, norm_layer=nn.LayerNorm, subln=False): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + + self.w1 = nn.Linear(in_features, hidden_features) + self.w2 = nn.Linear(in_features, hidden_features) + + self.act = act_layer() + self.ffn_ln = norm_layer(hidden_features) if subln else nn.Identity() + self.w3 = nn.Linear(hidden_features, out_features) + + self.drop = nn.Dropout(drop) + + def forward(self, x): + x1 = self.w1(x) + x2 = self.w2(x) + hidden = self.act(x1) * x2 + x = self.ffn_ln(hidden) + x = self.w3(x) + x = self.drop(x) + return x + + +class Attention(nn.Module): + def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0.0, proj_drop=0.0, window_size=None, attn_head_dim=None, xattn=False, rope=None, subln=False, norm_layer=nn.LayerNorm): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + if attn_head_dim is not None: + head_dim = attn_head_dim + all_head_dim = head_dim * self.num_heads + self.scale = qk_scale or head_dim**-0.5 + + self.subln = subln + if self.subln: + self.q_proj = nn.Linear(dim, all_head_dim, bias=False) + self.k_proj = nn.Linear(dim, all_head_dim, bias=False) + self.v_proj = nn.Linear(dim, all_head_dim, bias=False) + else: + self.qkv = nn.Linear(dim, all_head_dim * 3, bias=False) + + if qkv_bias: + self.q_bias = nn.Parameter(torch.zeros(all_head_dim)) + self.v_bias = nn.Parameter(torch.zeros(all_head_dim)) + else: + self.q_bias = None + self.v_bias = None + + if window_size: + self.window_size = window_size + self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3 + self.relative_position_bias_table = nn.Parameter(torch.zeros(self.num_relative_distance, num_heads)) # 2*Wh-1 * 2*Ww-1, nH + # cls to token & token 2 cls & cls to cls + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(window_size[0]) + coords_w = torch.arange(window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * window_size[1] - 1 + relative_position_index = torch.zeros(size=(window_size[0] * window_size[1] + 1,) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = self.num_relative_distance - 3 + relative_position_index[0:, 0] = self.num_relative_distance - 2 + relative_position_index[0, 0] = self.num_relative_distance - 1 + + self.register_buffer("relative_position_index", relative_position_index) + else: + self.window_size = None + self.relative_position_bias_table = None + self.relative_position_index = None + + self.attn_drop = nn.Dropout(attn_drop) + self.inner_attn_ln = norm_layer(all_head_dim) if subln else nn.Identity() + # self.proj = nn.Linear(all_head_dim, all_head_dim) + self.proj = nn.Linear(all_head_dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + self.xattn = xattn + self.xattn_drop = attn_drop + + self.rope = rope + + def forward(self, x, rel_pos_bias=None, attn_mask=None): + B, N, C = x.shape + if self.subln: + q = F.linear(input=x, weight=self.q_proj.weight, bias=self.q_bias) + k = F.linear(input=x, weight=self.k_proj.weight, bias=None) + v = F.linear(input=x, weight=self.v_proj.weight, bias=self.v_bias) + + q = q.reshape(B, N, self.num_heads, -1).permute(0, 2, 1, 3) # B, num_heads, N, C + k = k.reshape(B, N, self.num_heads, -1).permute(0, 2, 1, 3) + v = v.reshape(B, N, self.num_heads, -1).permute(0, 2, 1, 3) + else: + + qkv_bias = None + if self.q_bias is not None: + qkv_bias = torch.cat((self.q_bias, torch.zeros_like(self.v_bias, requires_grad=False), self.v_bias)) + + qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias) + qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) # 3, B, num_heads, N, C + q, k, v = qkv[0], qkv[1], qkv[2] + + if self.rope: + # slightly fast impl + q_t = q[:, :, 1:, :] + ro_q_t = self.rope(q_t) + q = torch.cat((q[:, :, :1, :], ro_q_t), -2).type_as(v) + + k_t = k[:, :, 1:, :] + ro_k_t = self.rope(k_t) + k = torch.cat((k[:, :, :1, :], ro_k_t), -2).type_as(v) + + if self.xattn and xops is not None: + q = q.permute(0, 2, 1, 3) # B, num_heads, N, C -> B, N, num_heads, C + k = k.permute(0, 2, 1, 3) + v = v.permute(0, 2, 1, 3) + + x = xops.memory_efficient_attention( + q, + k, + v, + p=self.xattn_drop, + scale=self.scale, + ) + x = x.reshape(B, N, -1) + x = self.inner_attn_ln(x) + x = self.proj(x) + x = self.proj_drop(x) + else: + q = q * self.scale + attn = q @ k.transpose(-2, -1) + + if self.relative_position_bias_table is not None: + relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(self.window_size[0] * self.window_size[1] + 1, self.window_size[0] * self.window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + attn = attn + relative_position_bias.unsqueeze(0).type_as(attn) + + if rel_pos_bias is not None: + attn = attn + rel_pos_bias.type_as(attn) + + if attn_mask is not None: + attn_mask = attn_mask.bool() + attn = attn.masked_fill(~attn_mask[:, None, None, :], float("-inf")) + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, -1) + x = self.inner_attn_ln(x) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +class Block(nn.Module): + + def __init__( + self, + dim, + num_heads, + mlp_ratio=4.0, + qkv_bias=False, + qk_scale=None, + drop=0.0, + attn_drop=0.0, + drop_path=0.0, + init_values=None, + act_layer=nn.GELU, + norm_layer=nn.LayerNorm, + window_size=None, + attn_head_dim=None, + xattn=False, + rope=None, + postnorm=False, + subln=False, + naiveswiglu=False, + ): + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop, window_size=window_size, attn_head_dim=attn_head_dim, xattn=xattn, rope=rope, subln=subln, norm_layer=norm_layer + ) + # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + + if naiveswiglu: + self.mlp = SwiGLU( + in_features=dim, + hidden_features=mlp_hidden_dim, + subln=subln, + norm_layer=norm_layer, + ) + else: + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, subln=subln, drop=drop) + + if init_values is not None and init_values > 0: + self.gamma_1 = nn.Parameter(init_values * torch.ones((dim)), requires_grad=True) + self.gamma_2 = nn.Parameter(init_values * torch.ones((dim)), requires_grad=True) + else: + self.gamma_1, self.gamma_2 = None, None + + self.postnorm = postnorm + + def forward(self, x, rel_pos_bias=None, attn_mask=None): + if self.gamma_1 is None: + if self.postnorm: + x = x + self.drop_path(self.norm1(self.attn(x, rel_pos_bias=rel_pos_bias, attn_mask=attn_mask))) + x = x + self.drop_path(self.norm2(self.mlp(x))) + else: + x = x + self.drop_path(self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias, attn_mask=attn_mask)) + x = x + self.drop_path(self.mlp(self.norm2(x))) + else: + if self.postnorm: + x = x + self.drop_path(self.gamma_1 * self.norm1(self.attn(x, rel_pos_bias=rel_pos_bias, attn_mask=attn_mask))) + x = x + self.drop_path(self.gamma_2 * self.norm2(self.mlp(x))) + else: + x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias, attn_mask=attn_mask)) + x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x))) + return x + + +class PatchEmbed(nn.Module): + """Image to Patch Embedding""" + + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.patch_shape = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x, **kwargs): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + +class RelativePositionBias(nn.Module): + + def __init__(self, window_size, num_heads): + super().__init__() + self.window_size = window_size + self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3 + self.relative_position_bias_table = nn.Parameter(torch.zeros(self.num_relative_distance, num_heads)) # 2*Wh-1 * 2*Ww-1, nH + # cls to token & token 2 cls & cls to cls + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(window_size[0]) + coords_w = torch.arange(window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * window_size[1] - 1 + relative_position_index = torch.zeros(size=(window_size[0] * window_size[1] + 1,) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = self.num_relative_distance - 3 + relative_position_index[0:, 0] = self.num_relative_distance - 2 + relative_position_index[0, 0] = self.num_relative_distance - 1 + + self.register_buffer("relative_position_index", relative_position_index) + + def forward(self): + relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(self.window_size[0] * self.window_size[1] + 1, self.window_size[0] * self.window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + return relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + + +class EVAVisionTransformer(nn.Module): + """Vision Transformer with support for patch or hybrid CNN input stage""" + + def __init__( + self, + img_size=224, + patch_size=16, + in_chans=3, + num_classes=1000, + embed_dim=768, + depth=12, + num_heads=12, + mlp_ratio=4.0, + qkv_bias=False, + qk_scale=None, + drop_rate=0.0, + attn_drop_rate=0.0, + drop_path_rate=0.0, + norm_layer=nn.LayerNorm, + init_values=None, + patch_dropout=0.0, + use_abs_pos_emb=True, + use_rel_pos_bias=False, + use_shared_rel_pos_bias=False, + rope=False, + use_mean_pooling=True, + init_scale=0.001, + grad_checkpointing=False, + xattn=False, + postnorm=False, + pt_hw_seq_len=16, + intp_freq=False, + naiveswiglu=False, + subln=False, + ): + super().__init__() + self.image_size = img_size + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models + + self.patch_embed = PatchEmbed(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + # self.mask_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + if use_abs_pos_emb: + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + else: + self.pos_embed = None + self.pos_drop = nn.Dropout(p=drop_rate) + + if use_shared_rel_pos_bias: + self.rel_pos_bias = RelativePositionBias(window_size=self.patch_embed.patch_shape, num_heads=num_heads) + else: + self.rel_pos_bias = None + + if rope: + half_head_dim = embed_dim // num_heads // 2 + hw_seq_len = img_size // patch_size + self.rope = VisionRotaryEmbeddingFast( + dim=half_head_dim, + pt_seq_len=pt_hw_seq_len, + ft_seq_len=hw_seq_len if intp_freq else None, + # patch_dropout=patch_dropout + ) + else: + self.rope = None + + self.naiveswiglu = naiveswiglu + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + self.use_rel_pos_bias = use_rel_pos_bias + self.blocks = nn.ModuleList( + [ + Block( + dim=embed_dim, + num_heads=num_heads, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, + qk_scale=qk_scale, + drop=drop_rate, + attn_drop=attn_drop_rate, + drop_path=dpr[i], + norm_layer=norm_layer, + init_values=init_values, + window_size=self.patch_embed.patch_shape if use_rel_pos_bias else None, + xattn=xattn, + rope=self.rope, + postnorm=postnorm, + subln=subln, + naiveswiglu=naiveswiglu, + ) + for i in range(depth) + ] + ) + self.norm = nn.Identity() if use_mean_pooling else norm_layer(embed_dim) + self.fc_norm = norm_layer(embed_dim) if use_mean_pooling else None + self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + if self.pos_embed is not None: + trunc_normal_(self.pos_embed, std=0.02) + + trunc_normal_(self.cls_token, std=0.02) + # trunc_normal_(self.mask_token, std=.02) + + self.apply(self._init_weights) + self.fix_init_weight() + + if isinstance(self.head, nn.Linear): + trunc_normal_(self.head.weight, std=0.02) + self.head.weight.data.mul_(init_scale) + self.head.bias.data.mul_(init_scale) + + # setting a patch_dropout of 0. would mean it is disabled and this function would be the identity fn + self.patch_dropout = PatchDropout(patch_dropout) if patch_dropout > 0.0 else nn.Identity() + + self.grad_checkpointing = grad_checkpointing + + def fix_init_weight(self): + def rescale(param, layer_id): + param.div_(math.sqrt(2.0 * layer_id)) + + for layer_id, layer in enumerate(self.blocks): + rescale(layer.attn.proj.weight.data, layer_id + 1) + if self.naiveswiglu: + rescale(layer.mlp.w3.weight.data, layer_id + 1) + else: + rescale(layer.mlp.fc2.weight.data, layer_id + 1) + + def get_cast_dtype(self) -> torch.dtype: + return self.blocks[0].mlp.fc2.weight.dtype + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + def get_num_layers(self): + return len(self.blocks) + + def lock(self, unlocked_groups=0, freeze_bn_stats=False): + assert unlocked_groups == 0, "partial locking not currently supported for this model" + for param in self.parameters(): + param.requires_grad = False + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.grad_checkpointing = enable + + @torch.jit.ignore + def no_weight_decay(self): + return {"pos_embed", "cls_token"} + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=""): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, x, return_all_features=False): + + x = self.patch_embed(x) + batch_size, seq_len, _ = x.size() + + cls_tokens = self.cls_token.expand(batch_size, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + if self.pos_embed is not None: + x = x + self.pos_embed + x = self.pos_drop(x) + + # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in + if os.getenv("RoPE") == "1": + if self.training and not isinstance(self.patch_dropout, nn.Identity): + x, patch_indices_keep = self.patch_dropout(x) + # Directly pass patch_indices_keep to self.rope.forward + x = self.rope.forward(x, patch_indices_keep=patch_indices_keep) + else: + # Pass None or omit the patch_indices_keep argument for default behavior + x = self.rope.forward(x, patch_indices_keep=None) + x = self.patch_dropout(x) + else: + x = self.patch_dropout(x) + + rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None + for i, blk in enumerate(self.blocks): + if i == len(self.blocks) - 1: + continue + if self.grad_checkpointing: + x = checkpoint(blk, x, (rel_pos_bias,)) + else: + x = blk(x, rel_pos_bias=rel_pos_bias) + + if not return_all_features: + x = self.norm(x) + if self.fc_norm is not None: + return self.fc_norm(x.mean(1)) + else: + return x[:, 0] + return x + + def forward(self, x, return_all_features=False): + if return_all_features: + return self.forward_features(x, return_all_features) + x = self.forward_features(x) + x = self.head(x) + return x + + +def load_state_dict(checkpoint_path: str, map_location: str = "cpu", model_key: str = "model|module|state_dict", is_openai: bool = False, skip_list: list = []): + if is_openai: + model = torch.jit.load(checkpoint_path, map_location="cpu").eval() + state_dict = model.state_dict() + for key in ["input_resolution", "context_length", "vocab_size"]: + state_dict.pop(key, None) + else: + checkpoint = torch.load(checkpoint_path, map_location=map_location) + for mk in model_key.split("|"): + if isinstance(checkpoint, dict) and mk in checkpoint: + state_dict = checkpoint[mk] + break + else: + state_dict = checkpoint + if next(iter(state_dict.items()))[0].startswith("module"): + state_dict = {k[7:]: v for k, v in state_dict.items()} + + for k in skip_list: + if k in list(state_dict.keys()): + logging.info(f"Removing key {k} from pretrained checkpoint") + del state_dict[k] + + if os.getenv("RoPE") == "1": + for k in list(state_dict.keys()): + if "freqs_cos" in k or "freqs_sin" in k: + del state_dict[k] + return state_dict + + +def load_clip_visual_state_dict(checkpoint_path: str, map_location: str = "cpu", is_openai: bool = False, skip_list: list = []): + state_dict = load_state_dict(checkpoint_path, map_location=map_location, is_openai=is_openai, skip_list=skip_list) + # for k in list(state_dict.keys()): + # if not k.startswith("visual."): + # del state_dict[k] + # for k in list(state_dict.keys()): + # if k.startswith("visual."): + # new_k = k[7:] + # state_dict[new_k] = state_dict[k] + # del state_dict[k] + return state_dict + + +from dataclasses import dataclass +from typing import Optional, Tuple, Union + +try: + from apex.normalization import FusedLayerNorm +except: + FusedLayerNorm = LayerNorm + # print("Please build and install Nvidia apex package with option '--cuda_ext' according to https://github.com/NVIDIA/apex#from-source .") + + +@dataclass +class CLIPVisionCfg: + layers: Union[Tuple[int, int, int, int], int] = 12 + width: int = 768 + head_width: int = 64 + mlp_ratio: float = 4.0 + patch_size: int = 16 + image_size: Union[Tuple[int, int], int] = 224 + ls_init_value: Optional[float] = None # layer scale initial value + patch_dropout: float = 0.0 # what fraction of patches to dropout during training (0 would mean disabled and no patches dropped) - 0.5 to 0.75 recommended in the paper for optimal results + global_average_pool: bool = False # whether to global average pool the last embedding layer, instead of using CLS token (https://arxiv.org/abs/2205.01580) + drop_path_rate: Optional[float] = None # drop path rate + timm_model_name: str = None # a valid model name overrides layers, width, patch_size + timm_model_pretrained: bool = False # use (imagenet) pretrained weights for named model + timm_pool: str = "avg" # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '') + timm_proj: str = "linear" # linear projection for timm model output ('linear', 'mlp', '') + timm_proj_bias: bool = False # enable bias final projection + eva_model_name: str = None # a valid eva model name overrides layers, width, patch_size + qkv_bias: bool = True + fusedLN: bool = False + xattn: bool = False + postnorm: bool = False + rope: bool = False + pt_hw_seq_len: int = 16 # 224/14 + intp_freq: bool = False + naiveswiglu: bool = False + subln: bool = False + + +def create_norm_layer_factory(use_fused_ln, eps=1e-6): + # Otherwise, use the standard LayerNorm + return lambda num_features: nn.LayerNorm(num_features, eps=eps) + + +def _build_vision_tower(vision_tower_path: str, embed_dim: int, vision_cfg: CLIPVisionCfg, **kwargs): + if isinstance(vision_cfg, dict): + vision_cfg = CLIPVisionCfg(**vision_cfg) + + if vision_cfg.eva_model_name: + vision_heads = vision_cfg.width // vision_cfg.head_width + # Determine the appropriate norm layer factory based on the configuration + norm_layer_factory = create_norm_layer_factory(vision_cfg.fusedLN, eps=1e-6) + + visual = EVAVisionTransformer( + img_size=vision_cfg.image_size, + patch_size=vision_cfg.patch_size, + num_classes=embed_dim, + use_mean_pooling=vision_cfg.global_average_pool, # False + init_values=vision_cfg.ls_init_value, + patch_dropout=vision_cfg.patch_dropout, + embed_dim=vision_cfg.width, + depth=vision_cfg.layers, + num_heads=vision_heads, + mlp_ratio=vision_cfg.mlp_ratio, + qkv_bias=vision_cfg.qkv_bias, + drop_path_rate=vision_cfg.drop_path_rate, + norm_layer=norm_layer_factory, + xattn=vision_cfg.xattn, + rope=vision_cfg.rope, + postnorm=vision_cfg.postnorm, + pt_hw_seq_len=vision_cfg.pt_hw_seq_len, # 224/14 + intp_freq=vision_cfg.intp_freq, + naiveswiglu=vision_cfg.naiveswiglu, + subln=vision_cfg.subln, + ) + + state_dict = load_clip_visual_state_dict(vision_tower_path) + incompatible_keys = visual.load_state_dict(state_dict, strict=False) + rank0_print("EVA-CLIP incompatible_keys:", incompatible_keys) + + return visual + + +class EVAEncoderWrapper(nn.Module): + def __init__(self, vision_tower_pretrained, config): + super(EVAEncoderWrapper, self).__init__() + self.config = config + self.config["vision_tower_path"] = vision_tower_pretrained + self.model = _build_vision_tower(**self.config) + + def forward(self, image, **kwargs): + encode = self.model(image, return_all_features=True)[:, 1:, :] # remove the CLS token + return encode + + @property + def dtype(self): + return list(self.parameters())[-1].dtype + + @property + def device(self): + return list(self.parameters())[-1].device diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/factory.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/factory.py new file mode 100644 index 0000000000000000000000000000000000000000..6d3fafcfd086c6c038a4577246f42c05264d5802 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/factory.py @@ -0,0 +1,60 @@ +import json +import logging +import os +import pathlib +import re +from copy import deepcopy +from pathlib import Path +from typing import Optional, Tuple, Union, Dict, Any +import torch + +_MODEL_CONFIG_PATHS = [Path(__file__).parent / f"model_configs/"] +_MODEL_CONFIGS = {} # directory (model_name: config) of model architecture configs + + +def _natural_key(string_): + return [int(s) if s.isdigit() else s for s in re.split(r"(\d+)", string_.lower())] + + +def _rescan_model_configs(): + global _MODEL_CONFIGS + + config_ext = (".json",) + config_files = [] + for config_path in _MODEL_CONFIG_PATHS: + if config_path.is_file() and config_path.suffix in config_ext: + config_files.append(config_path) + elif config_path.is_dir(): + for ext in config_ext: + config_files.extend(config_path.glob(f"*{ext}")) + + for cf in config_files: + with open(cf, "r", encoding="utf8") as f: + model_cfg = json.load(f) + if all(a in model_cfg for a in ("embed_dim", "vision_cfg", "text_cfg")): + _MODEL_CONFIGS[cf.stem] = model_cfg + + _MODEL_CONFIGS = dict(sorted(_MODEL_CONFIGS.items(), key=lambda x: _natural_key(x[0]))) + + +_rescan_model_configs() # initial populate of model config registry + + +def list_models(): + """enumerate available model architectures based on config files""" + return list(_MODEL_CONFIGS.keys()) + + +def add_model_config(path): + """add model config path or file and update registry""" + if not isinstance(path, Path): + path = Path(path) + _MODEL_CONFIG_PATHS.append(path) + _rescan_model_configs() + + +def get_model_config(model_name): + if model_name in _MODEL_CONFIGS: + return deepcopy(_MODEL_CONFIGS[model_name]) + else: + return None diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-18B.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-18B.json new file mode 100644 index 0000000000000000000000000000000000000000..4917556693fe9dcbddeadf7459be363740d55aa5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-18B.json @@ -0,0 +1,27 @@ +{ + "embed_dim": 1536, + "vision_cfg": { + "image_size": 224, + "layers": 48, + "width": 5120, + "head_width": 128, + "mlp_ratio": 5, + "patch_size": 14, + "eva_model_name": "eva-clip-18b-14-x", + "drop_path_rate": 0, + "qkv_bias": false, + "xattn": true, + "postnorm": true, + "fusedLN": false, + "use_rms_norm": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32, + "xattn": false, + "fusedLN": false + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-8B-plus.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-8B-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..7d843daa36c36b6100291fa3a2cb58672db6bbfb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-8B-plus.json @@ -0,0 +1,27 @@ +{ + "embed_dim": 1280, + "vision_cfg": { + "image_size": 448, + "layers": 32, + "width": 4096, + "head_width": 128, + "mlp_ratio": 5, + "patch_size": 14, + "eva_model_name": "eva-clip-8b-14-plus-x", + "drop_path_rate": 0, + "qkv_bias": false, + "xattn": true, + "postnorm": false, + "fusedLN": false, + "use_rms_norm": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32, + "xattn": false, + "fusedLN": false + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-8B.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-8B.json new file mode 100644 index 0000000000000000000000000000000000000000..689492a25d365436fd85ed432e6fb7295ca1c7bd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA-CLIP-8B.json @@ -0,0 +1,27 @@ +{ + "embed_dim": 1280, + "vision_cfg": { + "image_size": 224, + "layers": 32, + "width": 4096, + "head_width": 128, + "mlp_ratio": 5, + "patch_size": 14, + "eva_model_name": "eva-clip-8b-14-x", + "drop_path_rate": 0, + "qkv_bias": false, + "xattn": true, + "postnorm": false, + "fusedLN": false, + "use_rms_norm": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32, + "xattn": false, + "fusedLN": false + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-B-16.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-B-16.json new file mode 100644 index 0000000000000000000000000000000000000000..aad2058003962a4ab286bf4e1ae956288af34e62 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-B-16.json @@ -0,0 +1,19 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "patch_size": 16, + "eva_model_name": "eva-clip-b-16", + "ls_init_value": 0.1, + "drop_path_rate": 0.0 + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12 + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-g-14-plus.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-g-14-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..100279572ff6d1bcca601f0eb526b4d4ff174c7d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-g-14-plus.json @@ -0,0 +1,24 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 40, + "width": 1408, + "head_width": 88, + "mlp_ratio": 4.3637, + "patch_size": 14, + "eva_model_name": "eva-clip-g-14-x", + "drop_path_rate": 0, + "xattn": true, + "fusedLN": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24, + "xattn": false, + "fusedLN": true + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-g-14.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-g-14.json new file mode 100644 index 0000000000000000000000000000000000000000..5d338b4e6104241d1f0304ee82400035d5385332 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA01-CLIP-g-14.json @@ -0,0 +1,24 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 40, + "width": 1408, + "head_width": 88, + "mlp_ratio": 4.3637, + "patch_size": 14, + "eva_model_name": "eva-clip-g-14-x", + "drop_path_rate": 0.4, + "xattn": true, + "fusedLN": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12, + "xattn": false, + "fusedLN": true + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-B-16.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-B-16.json new file mode 100644 index 0000000000000000000000000000000000000000..e4a6e723f77033caa341ddf9b5be1787d64ad42c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-B-16.json @@ -0,0 +1,29 @@ +{ + "embed_dim": 512, + "vision_cfg": { + "image_size": 224, + "layers": 12, + "width": 768, + "head_width": 64, + "patch_size": 16, + "mlp_ratio": 2.6667, + "eva_model_name": "eva-clip-b-16-X", + "drop_path_rate": 0.0, + "xattn": true, + "fusedLN": true, + "rope": true, + "pt_hw_seq_len": 16, + "intp_freq": true, + "naiveswiglu": true, + "subln": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 512, + "heads": 8, + "layers": 12, + "xattn": true, + "fusedLN": true + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-L-14-336.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-L-14-336.json new file mode 100644 index 0000000000000000000000000000000000000000..3e1d124e1118911c5ad7b1ce85df195aca363ac4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-L-14-336.json @@ -0,0 +1,29 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 336, + "layers": 24, + "width": 1024, + "drop_path_rate": 0, + "head_width": 64, + "mlp_ratio": 2.6667, + "patch_size": 14, + "eva_model_name": "eva-clip-l-14-336", + "xattn": true, + "fusedLN": true, + "rope": true, + "pt_hw_seq_len": 16, + "intp_freq": true, + "naiveswiglu": true, + "subln": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12, + "xattn": false, + "fusedLN": true + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-L-14.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-L-14.json new file mode 100644 index 0000000000000000000000000000000000000000..03b22ad3cfb92f9c843b9ec8d672e57e7a9ba4a2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-L-14.json @@ -0,0 +1,29 @@ +{ + "embed_dim": 768, + "vision_cfg": { + "image_size": 224, + "layers": 24, + "width": 1024, + "drop_path_rate": 0, + "head_width": 64, + "mlp_ratio": 2.6667, + "patch_size": 14, + "eva_model_name": "eva-clip-l-14", + "xattn": true, + "fusedLN": true, + "rope": true, + "pt_hw_seq_len": 16, + "intp_freq": true, + "naiveswiglu": true, + "subln": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 768, + "heads": 12, + "layers": 12, + "xattn": false, + "fusedLN": true + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-bigE-14-plus.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-bigE-14-plus.json new file mode 100644 index 0000000000000000000000000000000000000000..aa04e2545ac1e015daae2c10133956ce969524f7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-bigE-14-plus.json @@ -0,0 +1,25 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 64, + "width": 1792, + "head_width": 112, + "mlp_ratio": 8.571428571428571, + "patch_size": 14, + "eva_model_name": "eva-clip-4b-14-x", + "drop_path_rate": 0, + "xattn": true, + "postnorm": true, + "fusedLN": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32, + "xattn": false, + "fusedLN": true + } +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-bigE-14.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-bigE-14.json new file mode 100644 index 0000000000000000000000000000000000000000..747ffccc8bd49dbb6701b58e15843b7fe3754e64 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/EVA02-CLIP-bigE-14.json @@ -0,0 +1,25 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 64, + "width": 1792, + "head_width": 112, + "mlp_ratio": 8.571428571428571, + "patch_size": 14, + "eva_model_name": "eva-clip-4b-14-x", + "drop_path_rate": 0, + "xattn": true, + "postnorm": true, + "fusedLN": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1024, + "heads": 16, + "layers": 24, + "xattn": false, + "fusedLN": true + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/Internal-EVA02-CLIP-10B-14-448.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/Internal-EVA02-CLIP-10B-14-448.json new file mode 100644 index 0000000000000000000000000000000000000000..ad71aff86a4d3b0e34c0bb55ea2b8e3ac220477a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/Internal-EVA02-CLIP-10B-14-448.json @@ -0,0 +1,25 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 448, + "layers": 77, + "width": 2304, + "head_width": 144, + "mlp_ratio": 10.9722, + "patch_size": 14, + "eva_model_name": "eva-clip-10b-14-x", + "drop_path_rate": 0, + "xattn": true, + "postnorm": false, + "fusedLN": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32, + "xattn": false, + "fusedLN": true + } +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/Internal-EVA02-CLIP-10B-14.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/Internal-EVA02-CLIP-10B-14.json new file mode 100644 index 0000000000000000000000000000000000000000..21b20680715e6e719b6c8d51c86701a4811ac37f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/eva_clip/model_configs/Internal-EVA02-CLIP-10B-14.json @@ -0,0 +1,25 @@ +{ + "embed_dim": 1024, + "vision_cfg": { + "image_size": 224, + "layers": 77, + "width": 2304, + "head_width": 144, + "mlp_ratio": 10.9722, + "patch_size": 14, + "eva_model_name": "eva-clip-10b-14-x", + "drop_path_rate": 0, + "xattn": true, + "postnorm": false, + "fusedLN": true + }, + "text_cfg": { + "context_length": 77, + "vocab_size": 49408, + "width": 1280, + "heads": 20, + "layers": 32, + "xattn": false, + "fusedLN": true + } +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/hf_vision.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/hf_vision.py new file mode 100644 index 0000000000000000000000000000000000000000..a413208e4028a10e8985818e50a2b078fdc19f8a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/hf_vision.py @@ -0,0 +1,111 @@ +import torch +import torch.nn as nn + +from transformers import AutoModel, AutoImageProcessor, AutoConfig, CLIPImageProcessor +from llava.utils import rank0_print + + +class HFVisionTower(nn.Module): + def __init__(self, vision_tower, args, delay_load=False): + super().__init__() + + self.is_loaded = False + + self.vision_tower_name = vision_tower.replace("hf:", "", 1) + self.select_layer = args.mm_vision_select_layer + self.select_feature = getattr(args, "mm_vision_select_feature", "patch") + + if not delay_load: + self.load_model() + else: + self.cfg_only = AutoConfig.from_pretrained(self.vision_tower_name) + + def load_model(self): + try: + self.image_processor = AutoImageProcessor.from_pretrained(self.vision_tower_name) + except Exception as e: + if "448" in self.vision_tower_name: + image_size = 448 + # use image processor with conig + self.image_processor = CLIPImageProcessor(size={"shortest_edge": image_size}, do_center_crop=True, crop_size=image_size) + else: + self.image_processor = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14") + rank0_print(f"Loaded image processor: {self.image_processor}") + self.vision_tower = AutoModel.from_pretrained(self.vision_tower_name, torch_dtype=torch.bfloat16, trust_remote_code=True).to("cuda") + self.device = self.vision_tower.device + self.dtype = self.vision_tower.dtype + self.config = self.vision_tower.config + + if hasattr(self.vision_tower, "vision_model"): + self.vision_tower = self.vision_tower.vision_model + self.vision_tower.requires_grad_(False) + # self.vision_tower.eval() + self.is_loaded = True + + def feature_select(self, image_forward_outs): + select_feature_type = self.select_feature + + if self.select_feature in ["slicefour_patch", "slicefour_cls_patch"]: + select_every_k_layer = len(image_forward_outs.hidden_states) // 4 + image_features = torch.cat([image_forward_outs.hidden_states[i] for i in range(select_every_k_layer + self.select_layer, len(image_forward_outs.hidden_states), select_every_k_layer)], dim=-1) + select_feature_type = select_feature_type.replace("slicefour_", "") + else: + image_features = image_forward_outs.hidden_states[self.select_layer] + + if select_feature_type == "patch": + image_features = image_features[:, 1:] + elif select_feature_type == "cls_patch": + image_features = image_features + else: + raise ValueError(f"Unexpected select feature: {select_feature_type}") + return image_features + + def forward(self, images): + if type(images) is list: + image_features = [] + for image in images: + image_forward_out = self.vision_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True) + image_feature = self.feature_select(image_forward_out).to(image.dtype) + image_features.append(image_feature) + else: + image_forward_outs = self.vision_tower(images.to(device=self.device, dtype=self.dtype), output_hidden_states=True) + image_features = self.feature_select(image_forward_outs).to(images.dtype) + + return image_features + + @property + def dummy_feature(self): + return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype) + + # @property + # def dtype(self): + # return self.vision_tower.dtype + + # @property + # def device(self): + # return self.vision_tower.device + + @property + def hidden_size(self): + try: + _hidden_size = self.config.hidden_size + except: + _hidden_size = self.config.vision_config.hidden_size + if "slicefour" in self.select_feature: + _hidden_size *= 4 + return _hidden_size + + @property + def num_patches(self): + _num_patches = (self.config.image_size // self.config.patch_size) ** 2 + if "cls_patch" in self.select_feature: + _num_patches += 1 + return _num_patches + + @property + def num_patches_per_side(self): + return self.config.image_size // self.config.patch_size + + @property + def image_size(self): + return self.config.image_size diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/imagebind.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/imagebind.py new file mode 100644 index 0000000000000000000000000000000000000000..8bbe71c7b42e25ff7e5a8912b403498002a26348 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/imagebind.py @@ -0,0 +1,73 @@ +import torch +import torch.nn as nn + +from transformers import CLIPImageProcessor + +try: + from imagebind.models import imagebind_model + from imagebind.models.imagebind_model import ModalityType + from imagebind.data import load_and_transform_audio_data +except ImportError: + pass + + +class ImageBindWrapper(nn.Module): + def __init__(self, vision_tower, select_layer, select_feature="patch", delay_load=False): + super().__init__() + + self.is_loaded = False + + self.vision_tower_name = vision_tower + self.select_layer = select_layer + self.select_feature = select_feature + + if not delay_load: + self.load_model() + + def load_model(self): + self.image_processor = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14") + self.vision_tower = imagebind_model.imagebind_huge(pretrained=True) + for p in self.vision_tower.parameters(): + p.requires_grad = False + self.vision_tower.eval() + self.is_loaded = True + + def train(self, mode=True): + self.training = mode + + if self.is_loaded: + self.vision_tower.eval() + + @torch.no_grad() + def forward(self, x): + if type(x) == dict: + if x["audios"] is not None: + inputs = {ModalityType.AUDIO: load_and_transform_audio_data(x["audios"], device=self.device).half()} + embeddings = self.vision_tower(inputs) + audio_embedding = embeddings[ModalityType.AUDIO] + return audio_embedding.unsqueeze(1) + else: + inputs = {ModalityType.VISION: x.to(dtype=self.dtype)} + embeddings = self.vision_tower(inputs) + vision_embedding = embeddings[ModalityType.VISION] + if vision_embedding.ndim == 2: + return vision_embedding.unsqueeze(1) + if vision_embedding.shape[1] == 257: + return vision_embedding[:, 1:] + raise ValueError(f"Unexpected shape: {vision_embedding.shape}") + + @property + def dummy_feature(self): + return torch.zeros(1, 1024, device=self.device, dtype=self.dtype) + + @property + def dtype(self): + return self.vision_tower.modality_preprocessors.vision.cls_token.dtype + + @property + def device(self): + return self.vision_tower.modality_preprocessors.vision.cls_token.device + + @property + def hidden_size(self): + return 1024 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/open_clip_encoder.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/open_clip_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..17a3277f99d1a36e443217d0ace0fb17bf5997cf --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/open_clip_encoder.py @@ -0,0 +1,163 @@ +import torch +import torch.nn as nn +from transformers import CLIPImageProcessor +from llava.utils import rank0_print + +try: + import open_clip + import torchvision + from open_clip.transformer import _expand_token +except ImportError: + print("OpenCLIP not installed") + open_clip = None + +HIDDEN_SIZE_DICT = { + "ViT-H-14-378-quickgelu": 1280, +} + + +class OpenCLIPVisionTower(nn.Module): + def __init__(self, vision_tower, args, delay_load=False): + super().__init__() + + self.is_loaded = False + self.model_name = vision_tower.replace("open_clip_hub:", "") + self.pretrained = args.vision_tower_pretrained + self.select_layer = args.mm_vision_select_layer + self.select_feature = getattr(args, "mm_vision_select_feature", "patch") + + if not delay_load: + rank0_print(f"Loading vision tower: {vision_tower}") + self.load_model() + elif getattr(args, "unfreeze_mm_vision_tower", False): + # TODO: better detector is needed. + rank0_print(f"The checkpoint seems to contain `vision_tower` weights: `unfreeze_mm_vision_tower`: True.") + self.load_model() + elif hasattr(args, "mm_tunable_parts") and "mm_vision_tower" in args.mm_tunable_parts: + rank0_print(f"The checkpoint seems to contain `vision_tower` weights: `mm_tunable_parts` contains `mm_vision_tower`.") + self.load_model() + + def load_model(self, device_map="auto"): + rank0_print(f"Loading OpenCLIP model: {self.model_name}") + rank0_print(f"Pretrained: {self.pretrained}") + vision_tower, _, image_processor = open_clip.create_model_and_transforms(model_name=self.model_name, pretrained=self.pretrained, precision="fp32", device="cuda") + + resize_transform = [t for t in image_processor.transforms if isinstance(t, torchvision.transforms.Resize)][0] + normalize_transform = [t for t in image_processor.transforms if isinstance(t, torchvision.transforms.Normalize)][0] + self.resize_transform_size = resize_transform.size # 224 or 384 + self.patch_size = vision_tower.visual.conv1.kernel_size[0] # 14 or 16 + + self.image_processor = CLIPImageProcessor.from_pretrained( + "openai/clip-vit-large-patch14", + crop_size=resize_transform.size, + size={"shortest_edge": resize_transform.size}, + image_mean=list(normalize_transform.mean), + image_std=list(normalize_transform.std), + ) + rank0_print(f"Loaded image processor: {self.image_processor}") + self.vision_tower = vision_tower.visual + self.vision_tower.requires_grad_(False) + + self.is_loaded = True + + def feature_select(self, image_forward_outs): + image_features = image_forward_outs[self.select_layer] + if self.select_feature == "patch": + image_features = image_features[:, 1:] + elif self.select_feature == "cls_patch": + image_features = image_features + elif self.select_feature == "conv_flatten": + image_features = image_features.flatten(2).transpose(1, 2) + else: + raise ValueError(f"Unexpected select feature: {self.select_feature}") + return image_features + + def forward_visual(self, x, output_hidden_states=False): + if hasattr(self.vision_tower, "trunk") and hasattr(self.vision_tower.trunk, "_intermediate_layers"): + return self.vision_tower.trunk._intermediate_layers(x, abs(self.select_layer)) + else: + + def forward_openclip(self, x: torch.Tensor): + features = [] + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + + # class embeddings and positional embeddings + x = torch.cat( + [_expand_token(self.class_embedding, x.shape[0]).to(x.dtype), x], + dim=1, + ) + # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + + x = self.patch_dropout(x) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + for r in self.transformer.resblocks: + x = r(x, attn_mask=None) + features.append(x) + return features + + return forward_openclip(self.vision_tower, x) + + def forward(self, images): + if type(images) is list: + image_features = [] + for image in images: + image_forward_out = self.forward_visual(image.to(self.dtype).unsqueeze(0), output_hidden_states=True) + image_feature = self.feature_select(image_forward_out).to(image.dtype) + image_features.append(image_feature) + else: + image_forward_outs = self.forward_visual(images.to(self.dtype), output_hidden_states=True) + image_features = self.feature_select(image_forward_outs).to(images.dtype) + + return image_features + + @property + def dummy_feature(self): + return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype) + + @property + def dtype(self): + if hasattr(self.vision_tower, "conv1"): + return self.vision_tower.conv1.weight.dtype + if hasattr(self.vision_tower, "trunk"): + return self.vision_tower.trunk.patch_embed.proj.weight.dtype + raise NotImplementedError + + @property + def device(self): + if hasattr(self.vision_tower, "conv1"): + return self.vision_tower.conv1.weight.device + if hasattr(self.vision_tower, "trunk"): + return self.vision_tower.trunk.patch_embed.proj.weight.device + raise NotImplementedError + + @property + def config(self): + return None + + @property + def hidden_size(self): + if self.model_name in HIDDEN_SIZE_DICT: + return HIDDEN_SIZE_DICT[self.model_name] + else: + raise NotImplementedError + + @property + def num_patches(self): + image_size = self.resize_transform_size if isinstance(self.resize_transform_size, int) else self.resize_transform_size[0] + _num_patches = (image_size // self.patch_size) ** 2 + if "cls_patch" in self.select_feature: + _num_patches += 1 + return _num_patches + + @property + def image_size(self): + return self.resize_transform_size + + @property + def num_patches_per_side(self): + return self.resize_transform_size // self.patch_size diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/siglip_encoder.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/siglip_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..f1e101a2fa29a8297541a72edcb20b1057665b33 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_encoder/siglip_encoder.py @@ -0,0 +1,620 @@ +""" +# Adapted from https://huggingface.co/MILVLG/imp-v1-3b/blob/main/vision_encoder.py +""" + +from typing import Optional, Tuple, Union, Dict +from dataclasses import dataclass +from functools import partial, reduce +from PIL import Image +import torch +import torch.utils.checkpoint +from torch import nn +import os +from transformers.image_processing_utils import BatchFeature, get_size_dict +from transformers.image_transforms import ( + convert_to_rgb, + normalize, + rescale, + resize, + to_channel_dimension_format, +) +from transformers.image_utils import ( + ChannelDimension, + PILImageResampling, + to_numpy_array, +) +from transformers.activations import ACT2FN +from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling +from transformers.modeling_utils import PreTrainedModel +from transformers import PretrainedConfig +from transformers.utils import ModelOutput +from llava.utils import rank0_print + + +class SigLipImageProcessor: + def __init__(self, image_mean=(0.5, 0.5, 0.5), image_std=(0.5, 0.5, 0.5), size=(384, 384), crop_size: Dict[str, int] = None, resample=PILImageResampling.BICUBIC, rescale_factor=1 / 255, data_format=ChannelDimension.FIRST): + crop_size = crop_size if crop_size is not None else {"height": 384, "width": 384} + crop_size = get_size_dict(crop_size, default_to_square=True, param_name="crop_size") + + self.image_mean = image_mean + self.image_std = image_std + self.size = size + self.resample = resample + self.rescale_factor = rescale_factor + self.data_format = data_format + self.crop_size = crop_size + + def preprocess(self, images, return_tensors): + if isinstance(images, Image.Image): + images = [images] + else: + # to adapt video data + images = [to_numpy_array(image) for image in images] + assert isinstance(images, list) + + transforms = [ + convert_to_rgb, + to_numpy_array, + partial(resize, size=self.size, resample=self.resample, data_format=self.data_format), + partial(rescale, scale=self.rescale_factor, data_format=self.data_format), + partial(normalize, mean=self.image_mean, std=self.image_std, data_format=self.data_format), + partial(to_channel_dimension_format, channel_dim=self.data_format, input_channel_dim=self.data_format), + ] + + images = reduce(lambda x, f: [*map(f, x)], transforms, images) + data = {"pixel_values": images} + + return BatchFeature(data=data, tensor_type=return_tensors) + + +class SigLipVisionConfig(PretrainedConfig): + model_type = "siglip_vision_model" + + def __init__( + self, + hidden_size=1152, + image_mean=(0.5, 0.5, 0.5), + intermediate_size=4304, + num_hidden_layers=27, + num_attention_heads=16, + num_channels=3, + image_size=384, + patch_size=14, + hidden_act="gelu_pytorch_tanh", + layer_norm_eps=1e-6, + attention_dropout=0.0, + **kwargs, + ): + super().__init__(**kwargs) + + self.hidden_size = hidden_size + self.intermediate_size = intermediate_size + self.num_hidden_layers = num_hidden_layers + self.num_attention_heads = num_attention_heads + self.num_channels = num_channels + self.patch_size = patch_size + self.image_size = image_size + self.attention_dropout = attention_dropout + self.layer_norm_eps = layer_norm_eps + self.hidden_act = hidden_act + self.image_mean = image_mean + + @classmethod + def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig": + cls._set_token_in_kwargs(kwargs) + + config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs) + + # get the vision config dict if we are loading from SigLipConfig + if config_dict.get("model_type") == "siglip": + config_dict = config_dict["vision_config"] + + if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type: + print(f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " f"{cls.model_type}. This is not supported for all configurations of models and can yield errors.") + + return cls.from_dict(config_dict, **kwargs) + + +@dataclass +# Copied from transformers.models.clip.modeling_clip.CLIPVisionModelOutput with CLIP->SigLip +class SigLipVisionModelOutput(ModelOutput): + """ + Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states. + + Args: + image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`): + The image embeddings obtained by applying the projection layer to the pooler_output. + last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): + Sequence of hidden-states at the output of the last layer of the model. + hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): + Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. + + Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. + attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): + Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, + sequence_length)`. + + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + """ + + image_embeds: Optional[torch.FloatTensor] = None + last_hidden_state: torch.FloatTensor = None + hidden_states: Optional[Tuple[torch.FloatTensor]] = None + attentions: Optional[Tuple[torch.FloatTensor]] = None + + +class SigLipVisionEmbeddings(nn.Module): + def __init__(self, config: SigLipVisionConfig): + super().__init__() + self.config = config + self.embed_dim = config.hidden_size + self.image_size = config.image_size + self.patch_size = config.patch_size + + self.patch_embedding = nn.Conv2d( + in_channels=config.num_channels, + out_channels=self.embed_dim, + kernel_size=self.patch_size, + stride=self.patch_size, + padding="valid", + ) + + self.num_patches = (self.image_size // self.patch_size) ** 2 + self.num_positions = self.num_patches + self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim) + self.register_buffer("position_ids", torch.arange(self.num_positions).expand((1, -1)), persistent=False) + + def forward(self, pixel_values: torch.FloatTensor) -> torch.Tensor: + patch_embeds = self.patch_embedding(pixel_values) # shape = [*, width, grid, grid] + embeddings = patch_embeds.flatten(2).transpose(1, 2) + + embeddings = embeddings + self.position_embedding(self.position_ids) + return embeddings + + +class SigLipAttention(nn.Module): + """Multi-headed attention from 'Attention Is All You Need' paper""" + + # Copied from transformers.models.clip.modeling_clip.CLIPAttention.__init__ + def __init__(self, config): + super().__init__() + self.config = config + self.embed_dim = config.hidden_size + self.num_heads = config.num_attention_heads + self.head_dim = self.embed_dim // self.num_heads + if self.head_dim * self.num_heads != self.embed_dim: + raise ValueError(f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:" f" {self.num_heads}).") + self.scale = self.head_dim**-0.5 + self.dropout = config.attention_dropout + + self.k_proj = nn.Linear(self.embed_dim, self.embed_dim) + self.v_proj = nn.Linear(self.embed_dim, self.embed_dim) + self.q_proj = nn.Linear(self.embed_dim, self.embed_dim) + self.out_proj = nn.Linear(self.embed_dim, self.embed_dim) + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + output_attentions: Optional[bool] = False, + ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: + """Input shape: Batch x Time x Channel""" + + batch_size, q_len, _ = hidden_states.size() + + query_states = self.q_proj(hidden_states) + key_states = self.k_proj(hidden_states) + value_states = self.v_proj(hidden_states) + + query_states = query_states.view(batch_size, q_len, self.num_heads, self.head_dim).transpose(1, 2) + key_states = key_states.view(batch_size, q_len, self.num_heads, self.head_dim).transpose(1, 2) + value_states = value_states.view(batch_size, q_len, self.num_heads, self.head_dim).transpose(1, 2) + + k_v_seq_len = key_states.shape[-2] + attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) * self.scale + + if attn_weights.size() != (batch_size, self.num_heads, q_len, k_v_seq_len): + raise ValueError(f"Attention weights should be of size {(batch_size, self.num_heads, q_len, k_v_seq_len)}, but is" f" {attn_weights.size()}") + + if attention_mask is not None: + if attention_mask.size() != (batch_size, 1, q_len, k_v_seq_len): + raise ValueError(f"Attention mask should be of size {(batch_size, 1, q_len, k_v_seq_len)}, but is {attention_mask.size()}") + attn_weights = attn_weights + attention_mask + + # upcast attention to fp32 + attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype) + attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training) + attn_output = torch.matmul(attn_weights, value_states) + + if attn_output.size() != (batch_size, self.num_heads, q_len, self.head_dim): + raise ValueError(f"`attn_output` should be of size {(batch_size, self.num_heads, q_len, self.head_dim)}, but is" f" {attn_output.size()}") + + attn_output = attn_output.transpose(1, 2).contiguous() + attn_output = attn_output.reshape(batch_size, q_len, self.embed_dim) + + attn_output = self.out_proj(attn_output) + + return attn_output, attn_weights + + +# Copied from transformers.models.clip.modeling_clip.CLIPMLP with CLIP->SigLip +class SigLipMLP(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.activation_fn = ACT2FN[config.hidden_act] + self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size) + self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size) + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + hidden_states = self.fc1(hidden_states) + hidden_states = self.activation_fn(hidden_states) + hidden_states = self.fc2(hidden_states) + return hidden_states + + +# Copied from transformers.models.clip.modeling_clip.CLIPEncoderLayer with CLIP->SigLip +class SigLipEncoderLayer(nn.Module): + def __init__(self, config: SigLipVisionConfig): + super().__init__() + self.embed_dim = config.hidden_size + self.self_attn = SigLipAttention(config) + self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps) + self.mlp = SigLipMLP(config) + self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps) + + # Ignore copy + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: torch.Tensor, + output_attentions: Optional[bool] = False, + ) -> Tuple[torch.FloatTensor]: + """ + Args: + hidden_states (`torch.FloatTensor`): + Input to the layer of shape `(batch, seq_len, embed_dim)`. + attention_mask (`torch.FloatTensor`): + Attention mask of shape `(batch, 1, q_len, k_v_seq_len)` where padding elements are indicated by very large negative values. + output_attentions (`bool`, *optional*, defaults to `False`): + Whether or not to return the attentions tensors of all attention layers. See `attentions` under + returned tensors for more detail. + """ + residual = hidden_states + + hidden_states = self.layer_norm1(hidden_states) + hidden_states, attn_weights = self.self_attn( + hidden_states=hidden_states, + attention_mask=attention_mask, + output_attentions=output_attentions, + ) + hidden_states = residual + hidden_states + + residual = hidden_states + hidden_states = self.layer_norm2(hidden_states) + hidden_states = self.mlp(hidden_states) + hidden_states = residual + hidden_states + + outputs = (hidden_states,) + + if output_attentions: + outputs += (attn_weights,) + + return outputs + + +class SigLipPreTrainedModel(PreTrainedModel): + """ + An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained + models. + """ + + config_class = SigLipVisionConfig + base_model_prefix = "siglip" + supports_gradient_checkpointing = True + + def _init_weights(self, module): + """Initialize the weights""" + pass + + +# Copied from transformers.models.clip.modeling_clip.CLIPEncoder with CLIP->SigLip +class SigLipEncoder(nn.Module): + """ + Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a + [`SigLipEncoderLayer`]. + + Args: + config: SigLipVisionConfig + """ + + def __init__(self, config: SigLipVisionConfig): + super().__init__() + self.config = config + self.layers = nn.ModuleList([SigLipEncoderLayer(config) for _ in range(config.num_hidden_layers)]) + self.gradient_checkpointing = False + + # Ignore copy + def forward( + self, + inputs_embeds, + attention_mask: Optional[torch.Tensor] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, BaseModelOutput]: + r""" + Args: + inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): + Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. + This is useful if you want more control over how to convert `input_ids` indices into associated vectors + than the model's internal embedding lookup matrix. + attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): + Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: + + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + + [What are attention masks?](../glossary#attention-mask) + output_attentions (`bool`, *optional*): + Whether or not to return the attentions tensors of all attention layers. See `attentions` under + returned tensors for more detail. + output_hidden_states (`bool`, *optional*): + Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors + for more detail. + return_dict (`bool`, *optional*): + Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. + """ + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + encoder_states = () if output_hidden_states else None + all_attentions = () if output_attentions else None + + hidden_states = inputs_embeds + for encoder_layer in self.layers: + if output_hidden_states: + encoder_states = encoder_states + (hidden_states,) + if self.gradient_checkpointing and self.training: + layer_outputs = self._gradient_checkpointing_func( + encoder_layer.__call__, + hidden_states, + attention_mask, + output_attentions, + ) + else: + layer_outputs = encoder_layer( + hidden_states, + attention_mask, + output_attentions=output_attentions, + ) + + hidden_states = layer_outputs[0] + + if output_attentions: + all_attentions = all_attentions + (layer_outputs[1],) + + if output_hidden_states: + encoder_states = encoder_states + (hidden_states,) + + if not return_dict: + return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None) + return BaseModelOutput(last_hidden_state=hidden_states, hidden_states=encoder_states, attentions=all_attentions) + + +class SigLipVisionTransformer(nn.Module): + def __init__(self, config: SigLipVisionConfig): + super().__init__() + self.config = config + embed_dim = config.hidden_size + + self.embeddings = SigLipVisionEmbeddings(config) + self.encoder = SigLipEncoder(config) + self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps) + self.head = SigLipMultiheadAttentionPoolingHead(config) + + def forward( + self, + pixel_values, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, BaseModelOutputWithPooling]: + r""" + Returns: + + """ + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + hidden_states = self.embeddings(pixel_values) + + encoder_outputs = self.encoder( + inputs_embeds=hidden_states, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + last_hidden_state = encoder_outputs[0] + last_hidden_state = self.post_layernorm(last_hidden_state) + + pooled_output = self.head(last_hidden_state) + + if not return_dict: + return (last_hidden_state, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPooling( + last_hidden_state=last_hidden_state, + pooler_output=pooled_output, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + ) + + +class SigLipMultiheadAttentionPoolingHead(nn.Module): + """Multihead Attention Pooling.""" + + def __init__(self, config: SigLipVisionConfig): + super().__init__() + + self.probe = nn.Parameter(torch.randn(1, 1, config.hidden_size)) + self.attention = torch.nn.MultiheadAttention(config.hidden_size, config.num_attention_heads, batch_first=True) + self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.mlp = SigLipMLP(config) + + def forward(self, hidden_state): + batch_size = hidden_state.shape[0] + probe = self.probe.repeat(batch_size, 1, 1) + + hidden_state = self.attention(probe, hidden_state, hidden_state)[0] + + residual = hidden_state + hidden_state = self.layernorm(hidden_state) + hidden_state = residual + self.mlp(hidden_state) + + return hidden_state[:, 0] + + +class SigLipVisionModel(SigLipPreTrainedModel): + config_class = SigLipVisionConfig + main_input_name = "pixel_values" + _no_split_modules = ["SigLipEncoderLayer"] + + def __init__(self, config: SigLipVisionConfig): + super().__init__(config) + + self.vision_model = SigLipVisionTransformer(config) + + # Initialize weights and apply final processing + self.post_init() + + def get_input_embeddings(self) -> nn.Module: + return self.vision_model.embeddings.patch_embedding + + def forward( + self, + pixel_values, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, BaseModelOutputWithPooling]: + r""" + Returns: + + Examples: + + ```python + >>> from PIL import Image + >>> import requests + >>> from transformers import AutoProcessor, SigLipVisionModel + + >>> model = SigLipVisionModel.from_pretrained("google/siglip-base-patch16-224") + >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224") + + >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" + >>> image = Image.open(requests.get(url, stream=True).raw) + + >>> inputs = processor(images=image, return_tensors="pt") + + >>> outputs = model(**inputs) + >>> last_hidden_state = outputs.last_hidden_state + >>> pooled_output = outputs.pooler_output # pooled features + ```""" + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + return self.vision_model( + pixel_values=pixel_values, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + +class SigLipVisionTower(nn.Module): + def __init__(self, vision_tower, vision_tower_cfg, delay_load=False): + super().__init__() + + self.is_loaded = False + + self.config = SigLipVisionConfig() + + self.vision_tower_name = vision_tower + + self.image_processor = SigLipImageProcessor() + + if not delay_load: + rank0_print(f"Loading vision tower: {vision_tower}") + self.load_model() + elif getattr(vision_tower_cfg, "unfreeze_mm_vision_tower", False): + # TODO: better detector is needed. + rank0_print(f"The checkpoint seems to contain `vision_tower` weights: `unfreeze_mm_vision_tower`: True.") + self.load_model() + elif hasattr(vision_tower_cfg, "mm_tunable_parts") and "mm_vision_tower" in vision_tower_cfg.mm_tunable_parts: + rank0_print(f"The checkpoint seems to contain `vision_tower` weights: `mm_tunable_parts` contains `mm_vision_tower`.") + self.load_model() + else: + self.cfg_only = self.config + + def load_model(self, device_map=None): + if self.is_loaded: + rank0_print("{} is already loaded, `load_model` called again, skipping.".format(self.vision_tower_name)) + return + + self.vision_tower = SigLipVisionModel.from_pretrained(self.vision_tower_name, device_map=device_map) + + del self.vision_tower.vision_model.encoder.layers[-1:] + self.vision_tower.vision_model.head = nn.Identity() + self.vision_tower.requires_grad_(False) + + self.is_loaded = True + + def forward(self, images): + if type(images) is list: + image_features = [] + for image in images: + image_forward_out = self.vision_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True) + image_feature = image_forward_out.hidden_states[-1].to(image.dtype) + assert image_features.shape[-2] == 729 + image_features.append(image_feature) + else: + image_forward_outs = self.vision_tower(images.to(device=self.device, dtype=self.dtype), output_hidden_states=True) + image_features = image_forward_outs.hidden_states[-1].to(images.dtype) + assert image_features.shape[-2] == 729 + + return image_features + + @property + def dummy_feature(self): + return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype) + + @property + def dtype(self): + for p in self.vision_tower.parameters(): + return p.dtype + + @property + def device(self): + for p in self.vision_tower.parameters(): + return p.device + + @property + def hidden_size(self): + return self.config.hidden_size + + @property + def num_patches(self): + return (self.config.image_size // self.config.patch_size) ** 2 + + @property + def num_patches_per_side(self): + return self.config.image_size // self.config.patch_size + # return self.model_config["vision_cfg"]["image_size"] // self.model_config["vision_cfg"]["patch_size"] + + @property + def image_size(self): + return self.config.image_size diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_projector/builder.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_projector/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..3122a0c3bc5b50f1c921ba9b186fd736f018c9cf --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_projector/builder.py @@ -0,0 +1,65 @@ +import torch +import torch.nn as nn +import re + +from .pooler_projector import PoolerProjector + + +class IdentityMap(nn.Module): + def __init__(self): + super().__init__() + + def forward(self, x, *args, **kwargs): + return x + + @property + def config(self): + return {"mm_projector_type": "identity"} + + +class SimpleResBlock(nn.Module): + def __init__(self, channels): + super().__init__() + self.pre_norm = nn.LayerNorm(channels) + + self.proj = nn.Sequential(nn.Linear(channels, channels), nn.GELU(), nn.Linear(channels, channels)) + + def forward(self, x): + x = self.pre_norm(x) + return x + self.proj(x) + + +def build_vision_projector(config, delay_load=False, **kwargs): + projector_type = getattr(config, "mm_projector_type", "linear") + + if projector_type == "linear": + return nn.Linear(config.mm_hidden_size, config.hidden_size) + + if projector_type == "pooler": + return PoolerProjector(config, kwargs["vision_cfg"]) + + mlp_gelu_match = re.match(r"^mlp(\d+)x_gelu$", projector_type) + if mlp_gelu_match: + mlp_depth = int(mlp_gelu_match.group(1)) + modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)] + for _ in range(1, mlp_depth): + modules.append(nn.GELU()) + modules.append(nn.Linear(config.hidden_size, config.hidden_size)) + return nn.Sequential(*modules) + + mlp_gelu_resnet_match = re.match(r"^mlp(\d+)x_res(\d+)x_gelu$", projector_type) + if mlp_gelu_resnet_match: + mlp_depth = int(mlp_gelu_resnet_match.group(1)) + res_depth = int(mlp_gelu_resnet_match.group(2)) + modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)] + for _ in range(1, mlp_depth): + modules.append(nn.GELU()) + modules.append(nn.Linear(config.hidden_size, config.hidden_size)) + for _ in range(res_depth): + modules.append(SimpleResBlock(config.hidden_size)) + return nn.Sequential(*modules) + + if projector_type == "identity": + return IdentityMap() + + raise ValueError(f"Unknown projector type: {projector_type}") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_projector/pooler_projector.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_projector/pooler_projector.py new file mode 100644 index 0000000000000000000000000000000000000000..ce5a2e05fa44ad2978272aea6dcf0aa9ca135e55 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_projector/pooler_projector.py @@ -0,0 +1,33 @@ +import torch +import torch.nn as nn + +import math + +from transformers.models.clip.modeling_clip import CLIPVisionModel + + +class PoolerProjector(nn.Module): + def __init__(self, config, vision_cfg): + super().__init__() + self._config = config + self.hw = vision_cfg.image_size // vision_cfg.patch_size + + self.conv_pool = nn.Conv2d(config.mm_hidden_size, config.hidden_size, kernel_size=2, stride=2) + + self.proj = nn.Sequential( + nn.GELU(), + nn.Linear(config.hidden_size, config.hidden_size), + ) + + def forward(self, x, *args, **kwargs): + height = width = self.hw + assert height * width == x.shape[1] + x = x.view(x.shape[0], height, width, -1).permute(0, 3, 1, 2) + x = self.conv_pool(x) + x = x.flatten(2).transpose(1, 2) + x = self.proj(x) + return x + + @property + def config(self): + return {"mm_projector_type": "pooler"} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/builder.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/builder.py new file mode 100644 index 0000000000000000000000000000000000000000..7a4b207f3bded33b89ddef3899233c3825d91701 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/builder.py @@ -0,0 +1,34 @@ +import torch + +from .masked_drop import MaskedDrop +from .spatial_pool import SpatialPool +from .perceiver import PerceiverResampler +from .qformer import Qformer + + +class IdentityMap(torch.nn.Module): + def __init__(self): + super().__init__() + + def forward(self, x, *args, **kwargs): + return x + + @property + def config(self): + return {"mm_resampler_type": None} + + +def build_vision_resampler(model_args, delay_load=False, **kwargs): + resampler_type = getattr(model_args, "mm_resampler_type", None) + if resampler_type == "masked_drop": + return MaskedDrop(model_args) + elif resampler_type == "spatial_pool": + return SpatialPool(model_args, **kwargs) + elif resampler_type == "perceiver": + return PerceiverResampler(model_args, **kwargs) + elif resampler_type == "qformer": + return Qformer(model_args, **kwargs) + elif resampler_type is None: + return IdentityMap() + + raise ValueError(f"Unknown resampler type: {resampler_type}") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/masked_drop.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/masked_drop.py new file mode 100644 index 0000000000000000000000000000000000000000..03f0bf0b259ff5d96adea4aad91ee5498d459030 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/masked_drop.py @@ -0,0 +1,80 @@ +import torch +import torch.nn as nn + +import random + + +class MaskedDrop(nn.Module): + def __init__(self, model_args): + super().__init__() + + self.mode = model_args.mm_mask_drop_mode + self.skip_percentage = model_args.mm_mask_drop_skip_percentage + self.ratio = model_args.mm_mask_drop_ratio + self.ratio_upper = model_args.mm_mask_drop_ratio_upper + self.ratio_lower = model_args.mm_mask_drop_ratio_lower + + def forward(self, image_features, *args, **kwargs): + + if not self.training: + return image_features + + if self.skip_percentage > random.random(): + return image_features + + masked_features = [] + + for image_feature in image_features: + num_tokens = image_feature.shape[0] + if self.mode == "fixed": + num_keep = int(num_tokens * self.ratio) + masked_features.append(self.random_masking(image_feature.unsqueeze(0), num_keep)[0][0]) + elif self.mode == "range": + num_keep = int(num_tokens * random.uniform(self.ratio_lower, self.ratio_upper)) + masked_features.append(self.random_masking(image_feature.unsqueeze(0), num_keep)[0]) + elif self.mode == "cls_only": + masked_features.append(image_feature[0:1]) + else: + raise ValueError(f"Unexpected masked drop mode: {self.mode}") + + if self.mode not in ["range"] and (type(image_features) is not list or self.mode in ["cls_only"]): + masked_features = torch.stack(masked_features, dim=0) + + return masked_features + + @property + def config(self): + return { + "mm_resampler_type": "masked_drop", + "mm_mask_drop_mode": self.mode, + "mm_mask_drop_skip_percentage": self.skip_percentage, + "mm_mask_drop_ratio": self.ratio, + "mm_mask_drop_ratio_upper": self.ratio_upper, + "mm_mask_drop_ratio_lower": self.ratio_lower, + } + + def random_masking(self, x, len_keep): + """ + Perform per-sample random masking by per-sample shuffling. + Per-sample shuffling is done by argsort random noise. + x: [N, L, D], sequence + """ + N, L, D = x.shape # batch, length, dim + + noise = torch.rand(N, L, device=x.device) # noise in [0, 1] + + # sort noise for each sample + ids_shuffle = torch.argsort(noise, dim=1) # ascend: small is keep, large is remove + ids_restore = torch.argsort(ids_shuffle, dim=1) + + # keep the first subset + ids_keep = ids_shuffle[:, :len_keep] + x_masked = torch.gather(x, dim=1, index=ids_keep.unsqueeze(-1).repeat(1, 1, D)) + + # generate the binary mask: 0 is keep, 1 is remove + mask = torch.ones([N, L], device=x.device) + mask[:, :len_keep] = 0 + # unshuffle to get the binary mask + mask = torch.gather(mask, dim=1, index=ids_restore) + + return x_masked, mask, ids_restore diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/perceiver.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/perceiver.py new file mode 100644 index 0000000000000000000000000000000000000000..d6b17a559b2225832c7d87c4fb6894617779b9c1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/perceiver.py @@ -0,0 +1,155 @@ +""" +Taken from https://github.com/lucidrains/flamingo-pytorch +""" + +import torch +from einops import rearrange, repeat + +try: + from einops_exts import rearrange_many +except: + pass + +from torch import einsum, nn + + +def exists(val): + return val is not None + + +def FeedForward(dim, mult=4): + inner_dim = int(dim * mult) + return nn.Sequential( + nn.LayerNorm(dim), + nn.Linear(dim, inner_dim, bias=False), + nn.GELU(), + nn.Linear(inner_dim, dim, bias=False), + ) + + +class PerceiverAttention(nn.Module): + def __init__(self, *, dim, dim_head=64, heads=8): + super().__init__() + self.scale = dim_head**-0.5 + self.heads = heads + inner_dim = dim_head * heads + + self.norm_media = nn.LayerNorm(dim) + self.norm_latents = nn.LayerNorm(dim) + + self.to_q = nn.Linear(dim, inner_dim, bias=False) + self.to_kv = nn.Linear(dim, inner_dim * 2, bias=False) + self.to_out = nn.Linear(inner_dim, dim, bias=False) + + def forward(self, x, latents): + """ + Args: + x (torch.Tensor): image features + shape (b, T, n1, D) + latent (torch.Tensor): latent features + shape (b, T, n2, D) + """ + x = self.norm_media(x) + latents = self.norm_latents(latents) + + h = self.heads + + q = self.to_q(latents) + kv_input = torch.cat((x, latents), dim=-2) + k, v = self.to_kv(kv_input).chunk(2, dim=-1) + q, k, v = rearrange_many((q, k, v), "b t n (h d) -> b h t n d", h=h) + q = q * self.scale + + # attention + sim = einsum("... i d, ... j d -> ... i j", q, k) + sim = sim - sim.amax(dim=-1, keepdim=True).detach() + attn = sim.softmax(dim=-1) + + out = einsum("... i j, ... j d -> ... i d", attn, v) + out = rearrange(out, "b h t n d -> b t n (h d)", h=h) + return self.to_out(out) + + +class PerceiverResamplerModule(nn.Module): + def __init__( + self, + *, + dim, + depth=6, + dim_head=64, + heads=8, + num_latents=64, + max_num_media=None, + max_num_frames=None, + ff_mult=4, + ): + super().__init__() + self.latents = nn.Parameter(torch.randn(num_latents, dim)) + self.frame_embs = nn.Parameter(torch.randn(max_num_frames, dim)) if exists(max_num_frames) else None + self.media_time_embs = nn.Parameter(torch.randn(max_num_media, 1, dim)) if exists(max_num_media) else None + + self.layers = nn.ModuleList([]) + for _ in range(depth): + self.layers.append( + nn.ModuleList( + [ + PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads), + FeedForward(dim=dim, mult=ff_mult) if ff_mult > 0 else nn.Identity(), + ] + ) + ) + + self.norm = nn.LayerNorm(dim) + + def forward(self, x): + """ + Args: + x (torch.Tensor): image features + shape (b, T, F, v, D) + Returns: + shape (b, T, n, D) where n is self.num_latents + """ + b, T, F, v = x.shape[:4] + + # frame and media time embeddings + if exists(self.frame_embs): + frame_embs = repeat(self.frame_embs[:F], "F d -> b T F v d", b=b, T=T, v=v) + x = x + frame_embs + x = rearrange(x, "b T F v d -> b T (F v) d") # flatten the frame and spatial dimensions + if exists(self.media_time_embs): + x = x + self.media_time_embs[:T] + + # blocks + latents = repeat(self.latents, "n d -> b T n d", b=b, T=T) + for attn, ff in self.layers: + latents = attn(x, latents) + latents + latents = ff(latents) + latents + return self.norm(latents) + + +class PerceiverResampler(nn.Module): + def __init__(self, model_args, vision_tower): + super().__init__() + + self.depth = model_args.mm_perceiver_depth + self.num_latents = model_args.mm_perceiver_latents + self.ff_mult = model_args.mm_perceiver_ff_mult + self.pretrained = model_args.mm_perceiver_pretrained + + self.perceiver = PerceiverResamplerModule(dim=vision_tower.hidden_size, depth=self.depth, num_latents=self.num_latents, ff_mult=self.ff_mult) + + if self.pretrained is not None: + self.load_state_dict(torch.load(self.pretrained)) + + def forward(self, image_features, *args, **kwargs): + return self.perceiver(image_features[:, None, None]).squeeze(1) + + @property + def config(self): + return { + "mm_resampler_type": "perceiver", + "mm_perceiver_depth": self.depth, + "mm_perceiver_latents": self.num_latents, + "mm_perceiver_ff_mult": self.ff_mult, + "mm_perceiver_pretrained": self.pretrained, + } diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/qformer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/qformer.py new file mode 100644 index 0000000000000000000000000000000000000000..b86754c24adbfa5ce34e37ee4726c74e3b7f910f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/qformer.py @@ -0,0 +1,1160 @@ +""" + * Copyright (c) 2023, salesforce.com, inc. + * All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause + * By Junnan Li + * Based on huggingface code base + * https://github.com/huggingface/transformers/blob/v4.15.0/src/transformers/models/bert +""" + +import math +import os +import warnings +from dataclasses import dataclass +from typing import Optional, Tuple, Dict, Any + +import torch +from torch import Tensor, device, dtype, nn +import torch.utils.checkpoint +from torch import nn +from torch.nn import CrossEntropyLoss +import torch.nn.functional as F + +from transformers.activations import ACT2FN +from transformers.file_utils import ( + ModelOutput, +) +from transformers.modeling_outputs import ( + BaseModelOutputWithPastAndCrossAttentions, + BaseModelOutputWithPoolingAndCrossAttentions, + CausalLMOutputWithCrossAttentions, + MaskedLMOutput, + MultipleChoiceModelOutput, + NextSentencePredictorOutput, + QuestionAnsweringModelOutput, + SequenceClassifierOutput, + TokenClassifierOutput, +) +from transformers.modeling_utils import ( + PreTrainedModel, + apply_chunking_to_forward, + find_pruneable_heads_and_indices, + prune_linear_layer, +) +from transformers.utils import logging +from transformers.models.bert.configuration_bert import BertConfig + +logger = logging.get_logger(__name__) + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class BertEmbeddings(nn.Module): + """Construct the embeddings from word and position embeddings.""" + + def __init__(self, config): + super().__init__() + self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id) + self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + # position_ids (1, len position emb) is contiguous in memory and exported when serialized + self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1))) + self.position_embedding_type = getattr(config, "position_embedding_type", "absolute") + + self.config = config + + def forward( + self, + input_ids=None, + position_ids=None, + query_embeds=None, + past_key_values_length=0, + ): + if input_ids is not None: + seq_length = input_ids.size()[1] + else: + seq_length = 0 + + if position_ids is None: + position_ids = self.position_ids[:, past_key_values_length : seq_length + past_key_values_length].clone() + + if input_ids is not None: + embeddings = self.word_embeddings(input_ids) + if self.position_embedding_type == "absolute": + position_embeddings = self.position_embeddings(position_ids) + embeddings = embeddings + position_embeddings + + if query_embeds is not None: + embeddings = torch.cat((query_embeds, embeddings), dim=1) + else: + embeddings = query_embeds + + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings) + return embeddings + + +class BertSelfAttention(nn.Module): + def __init__(self, config, is_cross_attention): + super().__init__() + self.config = config + if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"): + raise ValueError("The hidden size (%d) is not a multiple of the number of attention " "heads (%d)" % (config.hidden_size, config.num_attention_heads)) + + self.num_attention_heads = config.num_attention_heads + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.all_head_size = self.num_attention_heads * self.attention_head_size + + self.query = nn.Linear(config.hidden_size, self.all_head_size) + if is_cross_attention: + self.key = nn.Linear(config.encoder_width, self.all_head_size) + self.value = nn.Linear(config.encoder_width, self.all_head_size) + else: + self.key = nn.Linear(config.hidden_size, self.all_head_size) + self.value = nn.Linear(config.hidden_size, self.all_head_size) + + self.dropout = nn.Dropout(config.attention_probs_dropout_prob) + self.position_embedding_type = getattr(config, "position_embedding_type", "absolute") + if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query": + self.max_position_embeddings = config.max_position_embeddings + self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size) + self.save_attention = False + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def save_attention_map(self, attention_map): + self.attention_map = attention_map + + def get_attention_map(self): + return self.attention_map + + def transpose_for_scores(self, x): + new_x_shape = x.size()[:-1] + ( + self.num_attention_heads, + self.attention_head_size, + ) + x = x.view(*new_x_shape) + return x.permute(0, 2, 1, 3) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + ): + + # If this is instantiated as a cross-attention module, the keys + # and values come from an encoder; the attention mask needs to be + # such that the encoder's padding tokens are not attended to. + is_cross_attention = encoder_hidden_states is not None + + if is_cross_attention: + key_layer = self.transpose_for_scores(self.key(encoder_hidden_states)) + value_layer = self.transpose_for_scores(self.value(encoder_hidden_states)) + attention_mask = encoder_attention_mask + elif past_key_value is not None: + key_layer = self.transpose_for_scores(self.key(hidden_states)) + value_layer = self.transpose_for_scores(self.value(hidden_states)) + key_layer = torch.cat([past_key_value[0], key_layer], dim=2) + value_layer = torch.cat([past_key_value[1], value_layer], dim=2) + else: + key_layer = self.transpose_for_scores(self.key(hidden_states)) + value_layer = self.transpose_for_scores(self.value(hidden_states)) + + mixed_query_layer = self.query(hidden_states) + + query_layer = self.transpose_for_scores(mixed_query_layer) + + past_key_value = (key_layer, value_layer) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2)) + + if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query": + seq_length = hidden_states.size()[1] + position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1) + position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1) + distance = position_ids_l - position_ids_r + positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1) + positional_embedding = positional_embedding.to(dtype=query_layer.dtype) # fp16 compatibility + + if self.position_embedding_type == "relative_key": + relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding) + attention_scores = attention_scores + relative_position_scores + elif self.position_embedding_type == "relative_key_query": + relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding) + relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding) + attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key + + attention_scores = attention_scores / math.sqrt(self.attention_head_size) + if attention_mask is not None: + # Apply the attention mask is (precomputed for all layers in BertModel forward() function) + attention_scores = attention_scores + attention_mask + + # Normalize the attention scores to probabilities. + attention_probs = nn.Softmax(dim=-1)(attention_scores) + + if is_cross_attention and self.save_attention: + self.save_attention_map(attention_probs) + attention_probs.register_hook(self.save_attn_gradients) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs_dropped = self.dropout(attention_probs) + + # Mask heads if we want to + if head_mask is not None: + attention_probs_dropped = attention_probs_dropped * head_mask + + context_layer = torch.matmul(attention_probs_dropped, value_layer) + + context_layer = context_layer.permute(0, 2, 1, 3).contiguous() + new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,) + context_layer = context_layer.view(*new_context_layer_shape) + + outputs = (context_layer, attention_probs) if output_attentions else (context_layer,) + + outputs = outputs + (past_key_value,) + return outputs + + +class BertSelfOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class BertAttention(nn.Module): + def __init__(self, config, is_cross_attention=False): + super().__init__() + self.self = BertSelfAttention(config, is_cross_attention) + self.output = BertSelfOutput(config) + self.pruned_heads = set() + + def prune_heads(self, heads): + if len(heads) == 0: + return + heads, index = find_pruneable_heads_and_indices( + heads, + self.self.num_attention_heads, + self.self.attention_head_size, + self.pruned_heads, + ) + + # Prune linear layers + self.self.query = prune_linear_layer(self.self.query, index) + self.self.key = prune_linear_layer(self.self.key, index) + self.self.value = prune_linear_layer(self.self.value, index) + self.output.dense = prune_linear_layer(self.output.dense, index, dim=1) + + # Update hyper params and store pruned heads + self.self.num_attention_heads = self.self.num_attention_heads - len(heads) + self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads + self.pruned_heads = self.pruned_heads.union(heads) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + ): + self_outputs = self.self( + hidden_states, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + past_key_value, + output_attentions, + ) + attention_output = self.output(self_outputs[0], hidden_states) + + outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them + return outputs + + +class BertIntermediate(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.intermediate_size) + if isinstance(config.hidden_act, str): + self.intermediate_act_fn = ACT2FN[config.hidden_act] + else: + self.intermediate_act_fn = config.hidden_act + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + +class BertOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.intermediate_size, config.hidden_size) + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class BertLayer(nn.Module): + def __init__(self, config, layer_num): + super().__init__() + self.config = config + self.chunk_size_feed_forward = config.chunk_size_feed_forward + self.seq_len_dim = 1 + self.attention = BertAttention(config) + self.layer_num = layer_num + if self.config.add_cross_attention and layer_num % self.config.cross_attention_freq == 0: + self.crossattention = BertAttention(config, is_cross_attention=self.config.add_cross_attention) + self.has_cross_attention = True + else: + self.has_cross_attention = False + self.intermediate = BertIntermediate(config) + self.output = BertOutput(config) + + self.intermediate_query = BertIntermediate(config) + self.output_query = BertOutput(config) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + query_length=0, + ): + # decoder uni-directional self-attention cached key/values tuple is at positions 1,2 + self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None + self_attention_outputs = self.attention( + hidden_states, + attention_mask, + head_mask, + output_attentions=output_attentions, + past_key_value=self_attn_past_key_value, + ) + attention_output = self_attention_outputs[0] + outputs = self_attention_outputs[1:-1] + + present_key_value = self_attention_outputs[-1] + + if query_length > 0: + query_attention_output = attention_output[:, :query_length, :] + + if self.has_cross_attention: + assert encoder_hidden_states is not None, "encoder_hidden_states must be given for cross-attention layers" + cross_attention_outputs = self.crossattention( + query_attention_output, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + output_attentions=output_attentions, + ) + query_attention_output = cross_attention_outputs[0] + outputs = outputs + cross_attention_outputs[1:-1] # add cross attentions if we output attention weights + + layer_output = apply_chunking_to_forward( + self.feed_forward_chunk_query, + self.chunk_size_feed_forward, + self.seq_len_dim, + query_attention_output, + ) + if attention_output.shape[1] > query_length: + layer_output_text = apply_chunking_to_forward( + self.feed_forward_chunk, + self.chunk_size_feed_forward, + self.seq_len_dim, + attention_output[:, query_length:, :], + ) + layer_output = torch.cat([layer_output, layer_output_text], dim=1) + else: + layer_output = apply_chunking_to_forward( + self.feed_forward_chunk, + self.chunk_size_feed_forward, + self.seq_len_dim, + attention_output, + ) + outputs = (layer_output,) + outputs + + outputs = outputs + (present_key_value,) + + return outputs + + def feed_forward_chunk(self, attention_output): + intermediate_output = self.intermediate(attention_output) + layer_output = self.output(intermediate_output, attention_output) + return layer_output + + def feed_forward_chunk_query(self, attention_output): + intermediate_output = self.intermediate_query(attention_output) + layer_output = self.output_query(intermediate_output, attention_output) + return layer_output + + +class BertEncoder(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.layer = nn.ModuleList([BertLayer(config, i) for i in range(config.num_hidden_layers)]) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=False, + output_hidden_states=False, + return_dict=True, + query_length=0, + ): + all_hidden_states = () if output_hidden_states else None + all_self_attentions = () if output_attentions else None + all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None + + next_decoder_cache = () if use_cache else None + + for i in range(self.config.num_hidden_layers): + layer_module = self.layer[i] + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + layer_head_mask = head_mask[i] if head_mask is not None else None + past_key_value = past_key_values[i] if past_key_values is not None else None + + if getattr(self.config, "gradient_checkpointing", False) and self.training: + + if use_cache: + logger.warn("`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...") + use_cache = False + + def create_custom_forward(module): + def custom_forward(*inputs): + return module(*inputs, past_key_value, output_attentions, query_length) + + return custom_forward + + layer_outputs = torch.utils.checkpoint.checkpoint( + create_custom_forward(layer_module), + hidden_states, + attention_mask, + layer_head_mask, + encoder_hidden_states, + encoder_attention_mask, + ) + else: + layer_outputs = layer_module( + hidden_states, + attention_mask, + layer_head_mask, + encoder_hidden_states, + encoder_attention_mask, + past_key_value, + output_attentions, + query_length, + ) + + hidden_states = layer_outputs[0] + if use_cache: + next_decoder_cache += (layer_outputs[-1],) + if output_attentions: + all_self_attentions = all_self_attentions + (layer_outputs[1],) + all_cross_attentions = all_cross_attentions + (layer_outputs[2],) + + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + if not return_dict: + return tuple( + v + for v in [ + hidden_states, + next_decoder_cache, + all_hidden_states, + all_self_attentions, + all_cross_attentions, + ] + if v is not None + ) + return BaseModelOutputWithPastAndCrossAttentions( + last_hidden_state=hidden_states, + past_key_values=next_decoder_cache, + hidden_states=all_hidden_states, + attentions=all_self_attentions, + cross_attentions=all_cross_attentions, + ) + + +class BertPooler(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.activation = nn.Tanh() + + def forward(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + first_token_tensor = hidden_states[:, 0] + pooled_output = self.dense(first_token_tensor) + pooled_output = self.activation(pooled_output) + return pooled_output + + +class BertPredictionHeadTransform(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + if isinstance(config.hidden_act, str): + self.transform_act_fn = ACT2FN[config.hidden_act] + else: + self.transform_act_fn = config.hidden_act + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.transform_act_fn(hidden_states) + hidden_states = self.LayerNorm(hidden_states) + return hidden_states + + +class BertLMPredictionHead(nn.Module): + def __init__(self, config): + super().__init__() + self.transform = BertPredictionHeadTransform(config) + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + self.bias = nn.Parameter(torch.zeros(config.vocab_size)) + + # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings` + self.decoder.bias = self.bias + + def forward(self, hidden_states): + hidden_states = self.transform(hidden_states) + hidden_states = self.decoder(hidden_states) + return hidden_states + + +class BertOnlyMLMHead(nn.Module): + def __init__(self, config): + super().__init__() + self.predictions = BertLMPredictionHead(config) + + def forward(self, sequence_output): + prediction_scores = self.predictions(sequence_output) + return prediction_scores + + +class BertPreTrainedModel(PreTrainedModel): + """ + An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained + models. + """ + + config_class = BertConfig + base_model_prefix = "bert" + _keys_to_ignore_on_load_missing = [r"position_ids"] + + def _init_weights(self, module): + """Initialize the weights""" + if isinstance(module, (nn.Linear, nn.Embedding)): + # Slightly different from the TF version which uses truncated_normal for initialization + # cf https://github.com/pytorch/pytorch/pull/5617 + module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + +class BertModel(BertPreTrainedModel): + """ + The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of + cross-attention is added between the self-attention layers, following the architecture described in `Attention is + all you need `__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, + Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin. + argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an + input to the forward pass. + """ + + def __init__(self, config, add_pooling_layer=False): + super().__init__(config) + self.config = config + + self.embeddings = BertEmbeddings(config) + + self.encoder = BertEncoder(config) + + self.pooler = BertPooler(config) if add_pooling_layer else None + + self.init_weights() + + def get_input_embeddings(self): + return self.embeddings.word_embeddings + + def set_input_embeddings(self, value): + self.embeddings.word_embeddings = value + + def _prune_heads(self, heads_to_prune): + """ + Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base + class PreTrainedModel + """ + for layer, heads in heads_to_prune.items(): + self.encoder.layer[layer].attention.prune_heads(heads) + + def get_extended_attention_mask( + self, + attention_mask: Tensor, + input_shape: Tuple[int], + device: device, + is_decoder: bool, + has_query: bool = False, + ) -> Tensor: + """ + Makes broadcastable attention and causal masks so that future and masked tokens are ignored. + + Arguments: + attention_mask (:obj:`torch.Tensor`): + Mask with ones indicating tokens to attend to, zeros for tokens to ignore. + input_shape (:obj:`Tuple[int]`): + The shape of the input to the model. + device: (:obj:`torch.device`): + The device of the input to the model. + + Returns: + :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`. + """ + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + if attention_mask.dim() == 3: + extended_attention_mask = attention_mask[:, None, :, :] + elif attention_mask.dim() == 2: + # Provided a padding mask of dimensions [batch_size, seq_length] + # - if the model is a decoder, apply a causal mask in addition to the padding mask + # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length] + if is_decoder: + batch_size, seq_length = input_shape + + seq_ids = torch.arange(seq_length, device=device) + causal_mask = seq_ids[None, None, :].repeat(batch_size, seq_length, 1) <= seq_ids[None, :, None] + + # add a prefix ones mask to the causal mask + # causal and attention masks must have same type with pytorch version < 1.3 + causal_mask = causal_mask.to(attention_mask.dtype) + + if causal_mask.shape[1] < attention_mask.shape[1]: + prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1] + if has_query: # UniLM style attention mask + causal_mask = torch.cat( + [ + torch.zeros( + (batch_size, prefix_seq_len, seq_length), + device=device, + dtype=causal_mask.dtype, + ), + causal_mask, + ], + axis=1, + ) + causal_mask = torch.cat( + [ + torch.ones( + (batch_size, causal_mask.shape[1], prefix_seq_len), + device=device, + dtype=causal_mask.dtype, + ), + causal_mask, + ], + axis=-1, + ) + extended_attention_mask = causal_mask[:, None, :, :] * attention_mask[:, None, None, :] + else: + extended_attention_mask = attention_mask[:, None, None, :] + else: + raise ValueError("Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format(input_shape, attention_mask.shape)) + + # Since attention_mask is 1.0 for positions we want to attend and 0.0 for + # masked positions, this operation will create a tensor which is 0.0 for + # positions we want to attend and -10000.0 for masked positions. + # Since we are adding it to the raw scores before the softmax, this is + # effectively the same as removing these entirely. + extended_attention_mask = extended_attention_mask.to(dtype=self.dtype) # fp16 compatibility + extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0 + return extended_attention_mask + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + is_decoder=False, + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + """ + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + # use_cache = use_cache if use_cache is not None else self.config.use_cache + + if input_ids is None: + assert query_embeds is not None, "You have to specify query_embeds when input_ids is None" + + # past_key_values_length + past_key_values_length = past_key_values[0][0].shape[2] - self.config.query_length if past_key_values is not None else 0 + + query_length = query_embeds.shape[1] if query_embeds is not None else 0 + + embedding_output = self.embeddings( + input_ids=input_ids, + position_ids=position_ids, + query_embeds=query_embeds, + past_key_values_length=past_key_values_length, + ) + + input_shape = embedding_output.size()[:-1] + batch_size, seq_length = input_shape + device = embedding_output.device + + if attention_mask is None: + attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device) + + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + if is_decoder: + extended_attention_mask = self.get_extended_attention_mask( + attention_mask, + input_ids.shape, + device, + is_decoder, + has_query=(query_embeds is not None), + ) + else: + extended_attention_mask = self.get_extended_attention_mask(attention_mask, input_shape, device, is_decoder) + + # If a 2D or 3D attention mask is provided for the cross-attention + # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] + if encoder_hidden_states is not None: + if type(encoder_hidden_states) == list: + encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[0].size() + else: + ( + encoder_batch_size, + encoder_sequence_length, + _, + ) = encoder_hidden_states.size() + encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length) + + if type(encoder_attention_mask) == list: + encoder_extended_attention_mask = [self.invert_attention_mask(mask) for mask in encoder_attention_mask] + elif encoder_attention_mask is None: + encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device) + encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask) + else: + encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask) + else: + encoder_extended_attention_mask = None + + # Prepare head mask if needed + # 1.0 in head_mask indicate we keep the head + # attention_probs has shape bsz x n_heads x N x N + # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] + # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] + head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers) + + encoder_outputs = self.encoder( + embedding_output, + attention_mask=extended_attention_mask, + head_mask=head_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_extended_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + query_length=query_length, + ) + sequence_output = encoder_outputs[0] + pooled_output = self.pooler(sequence_output) if self.pooler is not None else None + + if not return_dict: + return (sequence_output, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPoolingAndCrossAttentions( + last_hidden_state=sequence_output, + pooler_output=pooled_output, + past_key_values=encoder_outputs.past_key_values, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + cross_attentions=encoder_outputs.cross_attentions, + ) + + +class BertLMHeadModel(BertPreTrainedModel): + + _keys_to_ignore_on_load_unexpected = [r"pooler"] + _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"] + + def __init__(self, config): + super().__init__(config) + + self.bert = BertModel(config, add_pooling_layer=False) + self.cls = BertOnlyMLMHead(config) + + self.init_weights() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + labels=None, + past_key_values=None, + use_cache=True, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + return_logits=False, + is_decoder=True, + reduction="mean", + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in + ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are + ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]`` + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + Returns: + Example:: + >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig + >>> import torch + >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased') + >>> config = BertConfig.from_pretrained("bert-base-cased") + >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config) + >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") + >>> outputs = model(**inputs) + >>> prediction_logits = outputs.logits + """ + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + if labels is not None: + use_cache = False + if past_key_values is not None: + query_embeds = None + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + head_mask=head_mask, + query_embeds=query_embeds, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + is_decoder=is_decoder, + ) + + sequence_output = outputs[0] + if query_embeds is not None: + sequence_output = outputs[0][:, query_embeds.shape[1] :, :] + + prediction_scores = self.cls(sequence_output) + + if return_logits: + return prediction_scores[:, :-1, :].contiguous() + + lm_loss = None + if labels is not None: + # we are doing next-token prediction; shift prediction scores and input ids by one + shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous() + labels = labels[:, 1:].contiguous() + loss_fct = CrossEntropyLoss(reduction=reduction, label_smoothing=0.1) + lm_loss = loss_fct( + shifted_prediction_scores.view(-1, self.config.vocab_size), + labels.view(-1), + ) + if reduction == "none": + lm_loss = lm_loss.view(prediction_scores.size(0), -1).sum(1) + + if not return_dict: + output = (prediction_scores,) + outputs[2:] + return ((lm_loss,) + output) if lm_loss is not None else output + + return CausalLMOutputWithCrossAttentions( + loss=lm_loss, + logits=prediction_scores, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + cross_attentions=outputs.cross_attentions, + ) + + def prepare_inputs_for_generation(self, input_ids, query_embeds, past=None, attention_mask=None, **model_kwargs): + # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly + if attention_mask is None: + attention_mask = input_ids.new_ones(input_ids.shape) + query_mask = input_ids.new_ones(query_embeds.shape[:-1]) + attention_mask = torch.cat([query_mask, attention_mask], dim=-1) + + # cut decoder_input_ids if past is used + if past is not None: + input_ids = input_ids[:, -1:] + + return { + "input_ids": input_ids, + "query_embeds": query_embeds, + "attention_mask": attention_mask, + "past_key_values": past, + "encoder_hidden_states": model_kwargs.get("encoder_hidden_states", None), + "encoder_attention_mask": model_kwargs.get("encoder_attention_mask", None), + "is_decoder": True, + } + + def _reorder_cache(self, past, beam_idx): + reordered_past = () + for layer_past in past: + reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),) + return reordered_past + + +class BertForMaskedLM(BertPreTrainedModel): + + _keys_to_ignore_on_load_unexpected = [r"pooler"] + _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"] + + def __init__(self, config): + super().__init__(config) + + self.bert = BertModel(config, add_pooling_layer=False) + self.cls = BertOnlyMLMHead(config) + + self.init_weights() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + labels=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + return_logits=False, + is_decoder=False, + ): + r""" + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ..., + config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored + (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]`` + """ + + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + head_mask=head_mask, + query_embeds=query_embeds, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + is_decoder=is_decoder, + ) + + if query_embeds is not None: + sequence_output = outputs[0][:, query_embeds.shape[1] :, :] + prediction_scores = self.cls(sequence_output) + + if return_logits: + return prediction_scores + + masked_lm_loss = None + if labels is not None: + loss_fct = CrossEntropyLoss() # -100 index = padding token + masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1)) + + if not return_dict: + output = (prediction_scores,) + outputs[2:] + return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output + + return MaskedLMOutput( + loss=masked_lm_loss, + logits=prediction_scores, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + +class Qformer(nn.Module): + def __init__(self, model_args, vision_tower): + super().__init__() + + self.depth = model_args.mm_qformer_depth + self.num_latents = model_args.mm_qformer_latents + self.pretrained = model_args.mm_qformer_pretrained + + self.Qformer, self.query_tokens, self.ln_vision = self.build_Qformer(vision_tower.hidden_size, self.depth, self.num_latents) + + if self.pretrained is not None: + pretrained_dict = torch.load(self.pretrained, map_location="cpu")["model"] + pretrained_dict = {k: v for k, v in pretrained_dict.items() if not k.startswith("t5_proj")} + self.load_state_dict(pretrained_dict) + + def build_Qformer(self, vision_width, cross_attention_freq, num_query_token): + encoder_config = BertConfig.from_pretrained("bert-base-uncased") + encoder_config.encoder_width = vision_width + # insert cross-attention layer every other block + encoder_config.add_cross_attention = True + encoder_config.cross_attention_freq = cross_attention_freq + encoder_config.query_length = num_query_token + Qformer = BertLMHeadModel(config=encoder_config) + query_tokens = nn.Parameter(torch.zeros(1, num_query_token, encoder_config.hidden_size)) + query_tokens.data.normal_(mean=0.0, std=encoder_config.initializer_range) + Qformer.cls = None + Qformer.bert.embeddings.word_embeddings = None + Qformer.bert.embeddings.position_embeddings = None + for layer in Qformer.bert.encoder.layer: + layer.output = None + layer.intermediate = None + return Qformer, query_tokens, nn.LayerNorm(vision_width) + + def forward(self, image_features, *args, **kwargs): + x = self.ln_vision(image_features) + image_atts = torch.ones(x.size()[:-1], dtype=torch.long).to(x.device) + + query_tokens = self.query_tokens.expand(x.shape[0], -1, -1) + query_output = self.Qformer.bert( + query_embeds=query_tokens, + encoder_hidden_states=x, + encoder_attention_mask=image_atts, + return_dict=True, + ) + + return query_output.last_hidden_state + + @property + def hidden_size(self): + return 768 + + @property + def config(self): + return { + "mm_resampler_type": "qformer", + "mm_qformer_depth": self.depth, + "mm_qformer_latents": self.num_latents, + "mm_qformer_pretrained": self.pretrained, + } diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/spatial_pool.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/spatial_pool.py new file mode 100644 index 0000000000000000000000000000000000000000..4bdbe3aecc91183341816c800c8ad1fcfba9a169 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/multimodal_resampler/spatial_pool.py @@ -0,0 +1,45 @@ +import torch +import torch.nn as nn +import math + + +class SpatialPool(nn.Module): + def __init__(self, model_args, vision_tower): + super().__init__() + + self.mode = model_args.mm_spatial_pool_mode + self.stride = model_args.mm_spatial_pool_stride + self.out_channels = getattr(model_args, "mm_spatial_pool_out_channels", vision_tower.hidden_size) + + if self.mode == "average": + self.pool = nn.AvgPool2d(kernel_size=self.stride, stride=self.stride) + elif self.mode == "max": + self.pool = nn.MaxPool2d(kernel_size=self.stride, stride=self.stride) + elif self.mode == "conv": + self.pool = nn.Conv2d(in_channels=vision_tower.hidden_size, out_channels=self.out_channels, kernel_size=self.stride, stride=self.stride) + else: + raise ValueError(f"Unknown pooling mode: {self.pool}.") + + def forward(self, image_features, images, *args, **kwargs): + ori_W = int(math.sqrt(image_features.shape[1] * images.shape[3] // images.shape[2])) + ori_H = int(ori_W * images.shape[2] // images.shape[3]) + + B, _, F = image_features.shape + + image_features_spatial = image_features.view(B, ori_H, ori_H, F).permute(0, 3, 1, 2) + image_features_spatial_pool = self.pool(image_features_spatial) + + return image_features_spatial_pool.flatten(2).transpose(1, 2).contiguous() + + @property + def config(self): + return { + "mm_resampler_type": "spatial_pool", + "mm_spatial_pool_stride": self.stride, + "mm_spatial_pool_mode": self.mode, + "mm_spatial_pool_out_channels": self.out_channels, + } + + @property + def hidden_size(self): + return self.out_channels diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..10652a5f9aaa2e0cddaef0b1a7bc39013a0d957b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/model/utils.py @@ -0,0 +1,20 @@ +from transformers import AutoConfig + + +def auto_upgrade(config): + cfg = AutoConfig.from_pretrained(config) + if "llava" in config and "llava" not in cfg.model_type: + assert cfg.model_type == "llama" + print("You are using newer LLaVA code base, while the checkpoint of v0 is from older code base.") + print("You must upgrade the checkpoint to the new code base (this can be done automatically).") + confirm = input("Please confirm that you want to upgrade the checkpoint. [Y/N]") + if confirm.lower() in ["y", "yes"]: + print("Upgrading checkpoint...") + assert len(cfg.architectures) == 1 + setattr(cfg.__class__, "model_type", "llava") + cfg.architectures[0] = "LlavaLlamaForCausalLM" + cfg.save_pretrained(config) + print("Checkpoint upgraded.") + else: + print("Checkpoint upgrade aborted.") + exit(1) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/cli.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..88fbfe85dac4e385962c8c83e074af0fa34c2353 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/cli.py @@ -0,0 +1,111 @@ +import argparse +import torch + +from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN +from llava.conversation import conv_templates, SeparatorStyle +from llava.model.builder import load_pretrained_model +from llava.utils import disable_torch_init +from llava.mm_utils import tokenizer_image_token, get_model_name_from_path, KeywordsStoppingCriteria + +from PIL import Image + +import requests +from PIL import Image +from io import BytesIO +from transformers import TextStreamer + + +def load_image(image_file): + if image_file.startswith("http") or image_file.startswith("https"): + response = requests.get(image_file) + image = Image.open(BytesIO(response.content)).convert("RGB") + else: + image = Image.open(image_file).convert("RGB") + return image + + +def main(args): + # Model + disable_torch_init() + + model_name = get_model_name_from_path(args.model_path) + tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name, args.load_8bit, args.load_4bit) + + if "llama-2" in model_name.lower(): + conv_mode = "llava_llama_2" + elif "v1" in model_name.lower(): + conv_mode = "llava_v1" + elif "mpt" in model_name.lower(): + conv_mode = "mpt" + else: + conv_mode = "llava_v0" + + if args.conv_mode is not None and conv_mode != args.conv_mode: + print("[WARNING] the auto inferred conversation mode is {}, while `--conv-mode` is {}, using {}".format(conv_mode, args.conv_mode, args.conv_mode)) + else: + args.conv_mode = conv_mode + + conv = conv_templates[args.conv_mode].copy() + if "mpt" in model_name.lower(): + roles = ("user", "assistant") + else: + roles = conv.roles + + image = load_image(args.image_file) + image_tensor = image_processor.preprocess(image, return_tensors="pt")["pixel_values"].half().cuda() + + while True: + try: + inp = input(f"{roles[0]}: ") + except EOFError: + inp = "" + if not inp: + print("exit...") + break + + print(f"{roles[1]}: ", end="") + + if image is not None: + # first message + if model.config.mm_use_im_start_end: + inp = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + "\n" + inp + else: + inp = DEFAULT_IMAGE_TOKEN + "\n" + inp + conv.append_message(conv.roles[0], inp) + image = None + else: + # later messages + conv.append_message(conv.roles[0], inp) + conv.append_message(conv.roles[1], None) + prompt = conv.get_prompt() + + input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt").unsqueeze(0).cuda() + stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2 + keywords = [stop_str] + stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids) + streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True) + + with torch.inference_mode(): + output_ids = model.generate(input_ids, images=image_tensor, do_sample=True, temperature=0.2, max_new_tokens=1024, streamer=streamer, use_cache=True, stopping_criteria=[stopping_criteria]) + + outputs = tokenizer.decode(output_ids[0, input_ids.shape[1] :]).strip() + conv.messages[-1][-1] = outputs + + if args.debug: + print("\n", {"prompt": prompt, "outputs": outputs}, "\n") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--model-path", type=str, default="facebook/opt-350m") + parser.add_argument("--model-base", type=str, default=None) + parser.add_argument("--image-file", type=str, required=True) + parser.add_argument("--num-gpus", type=int, default=1) + parser.add_argument("--conv-mode", type=str, default=None) + parser.add_argument("--temperature", type=float, default=0.2) + parser.add_argument("--max-new-tokens", type=int, default=512) + parser.add_argument("--load-8bit", action="store_true") + parser.add_argument("--load-4bit", action="store_true") + parser.add_argument("--debug", action="store_true") + args = parser.parse_args() + main(args) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/controller.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/controller.py new file mode 100644 index 0000000000000000000000000000000000000000..261f8c6bd4461e723fff4c7a7557fe10d592bca9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/controller.py @@ -0,0 +1,287 @@ +""" +A controller manages distributed workers. +It sends worker addresses to clients. +""" + +import argparse +import asyncio +import dataclasses +from enum import Enum, auto +import json +import logging +import time +from typing import List, Union +import threading + +from fastapi import FastAPI, Request +from fastapi.responses import StreamingResponse +import numpy as np +import requests +import uvicorn + +from llava.constants import CONTROLLER_HEART_BEAT_EXPIRATION +from llava.utils import build_logger, server_error_msg + + +logger = build_logger("controller", "controller.log") + + +class DispatchMethod(Enum): + LOTTERY = auto() + SHORTEST_QUEUE = auto() + + @classmethod + def from_str(cls, name): + if name == "lottery": + return cls.LOTTERY + elif name == "shortest_queue": + return cls.SHORTEST_QUEUE + else: + raise ValueError(f"Invalid dispatch method") + + +@dataclasses.dataclass +class WorkerInfo: + model_names: List[str] + speed: int + queue_length: int + check_heart_beat: bool + last_heart_beat: str + + +def heart_beat_controller(controller): + while True: + time.sleep(CONTROLLER_HEART_BEAT_EXPIRATION) + controller.remove_stable_workers_by_expiration() + + +class Controller: + def __init__(self, dispatch_method: str): + # Dict[str -> WorkerInfo] + self.worker_info = {} + self.dispatch_method = DispatchMethod.from_str(dispatch_method) + + self.heart_beat_thread = threading.Thread(target=heart_beat_controller, args=(self,)) + self.heart_beat_thread.start() + + logger.info("Init controller") + + def register_worker(self, worker_name: str, check_heart_beat: bool, worker_status: dict): + if worker_name not in self.worker_info: + logger.info(f"Register a new worker: {worker_name}") + else: + logger.info(f"Register an existing worker: {worker_name}") + + if not worker_status: + worker_status = self.get_worker_status(worker_name) + if not worker_status: + return False + + self.worker_info[worker_name] = WorkerInfo(worker_status["model_names"], worker_status["speed"], worker_status["queue_length"], check_heart_beat, time.time()) + + logger.info(f"Register done: {worker_name}, {worker_status}") + return True + + def get_worker_status(self, worker_name: str): + try: + r = requests.post(worker_name + "/worker_get_status", timeout=5) + except requests.exceptions.RequestException as e: + logger.error(f"Get status fails: {worker_name}, {e}") + return None + + if r.status_code != 200: + logger.error(f"Get status fails: {worker_name}, {r}") + return None + + return r.json() + + def remove_worker(self, worker_name: str): + del self.worker_info[worker_name] + + def refresh_all_workers(self): + old_info = dict(self.worker_info) + self.worker_info = {} + + for w_name, w_info in old_info.items(): + if not self.register_worker(w_name, w_info.check_heart_beat, None): + logger.info(f"Remove stale worker: {w_name}") + + def list_models(self): + model_names = set() + + for w_name, w_info in self.worker_info.items(): + model_names.update(w_info.model_names) + + return list(model_names) + + def get_worker_address(self, model_name: str): + if self.dispatch_method == DispatchMethod.LOTTERY: + worker_names = [] + worker_speeds = [] + for w_name, w_info in self.worker_info.items(): + if model_name in w_info.model_names: + worker_names.append(w_name) + worker_speeds.append(w_info.speed) + worker_speeds = np.array(worker_speeds, dtype=np.float32) + norm = np.sum(worker_speeds) + if norm < 1e-4: + return "" + worker_speeds = worker_speeds / norm + if True: # Directly return address + pt = np.random.choice(np.arange(len(worker_names)), p=worker_speeds) + worker_name = worker_names[pt] + return worker_name + + # Check status before returning + while True: + pt = np.random.choice(np.arange(len(worker_names)), p=worker_speeds) + worker_name = worker_names[pt] + + if self.get_worker_status(worker_name): + break + else: + self.remove_worker(worker_name) + worker_speeds[pt] = 0 + norm = np.sum(worker_speeds) + if norm < 1e-4: + return "" + worker_speeds = worker_speeds / norm + continue + return worker_name + elif self.dispatch_method == DispatchMethod.SHORTEST_QUEUE: + worker_names = [] + worker_qlen = [] + for w_name, w_info in self.worker_info.items(): + if model_name in w_info.model_names: + worker_names.append(w_name) + worker_qlen.append(w_info.queue_length / w_info.speed) + if len(worker_names) == 0: + return "" + min_index = np.argmin(worker_qlen) + w_name = worker_names[min_index] + self.worker_info[w_name].queue_length += 1 + logger.info(f"names: {worker_names}, queue_lens: {worker_qlen}, ret: {w_name}") + return w_name + else: + raise ValueError(f"Invalid dispatch method: {self.dispatch_method}") + + def receive_heart_beat(self, worker_name: str, queue_length: int): + if worker_name not in self.worker_info: + logger.info(f"Receive unknown heart beat. {worker_name}") + return False + + self.worker_info[worker_name].queue_length = queue_length + self.worker_info[worker_name].last_heart_beat = time.time() + logger.info(f"Receive heart beat. {worker_name}") + return True + + def remove_stable_workers_by_expiration(self): + expire = time.time() - CONTROLLER_HEART_BEAT_EXPIRATION + to_delete = [] + for worker_name, w_info in self.worker_info.items(): + if w_info.check_heart_beat and w_info.last_heart_beat < expire: + to_delete.append(worker_name) + + for worker_name in to_delete: + self.remove_worker(worker_name) + + def worker_api_generate_stream(self, params): + worker_addr = self.get_worker_address(params["model"]) + if not worker_addr: + logger.info(f"no worker: {params['model']}") + ret = { + "text": server_error_msg, + "error_code": 2, + } + yield json.dumps(ret).encode() + b"\0" + + try: + response = requests.post(worker_addr + "/worker_generate_stream", json=params, stream=True, timeout=5) + for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"): + if chunk: + yield chunk + b"\0" + except requests.exceptions.RequestException as e: + logger.info(f"worker timeout: {worker_addr}") + ret = { + "text": server_error_msg, + "error_code": 3, + } + yield json.dumps(ret).encode() + b"\0" + + # Let the controller act as a worker to achieve hierarchical + # management. This can be used to connect isolated sub networks. + def worker_api_get_status(self): + model_names = set() + speed = 0 + queue_length = 0 + + for w_name in self.worker_info: + worker_status = self.get_worker_status(w_name) + if worker_status is not None: + model_names.update(worker_status["model_names"]) + speed += worker_status["speed"] + queue_length += worker_status["queue_length"] + + return { + "model_names": list(model_names), + "speed": speed, + "queue_length": queue_length, + } + + +app = FastAPI() + + +@app.post("/register_worker") +async def register_worker(request: Request): + data = await request.json() + controller.register_worker(data["worker_name"], data["check_heart_beat"], data.get("worker_status", None)) + + +@app.post("/refresh_all_workers") +async def refresh_all_workers(): + models = controller.refresh_all_workers() + + +@app.post("/list_models") +async def list_models(): + models = controller.list_models() + return {"models": models} + + +@app.post("/get_worker_address") +async def get_worker_address(request: Request): + data = await request.json() + addr = controller.get_worker_address(data["model"]) + return {"address": addr} + + +@app.post("/receive_heart_beat") +async def receive_heart_beat(request: Request): + data = await request.json() + exist = controller.receive_heart_beat(data["worker_name"], data["queue_length"]) + return {"exist": exist} + + +@app.post("/worker_generate_stream") +async def worker_api_generate_stream(request: Request): + params = await request.json() + generator = controller.worker_api_generate_stream(params) + return StreamingResponse(generator) + + +@app.post("/worker_get_status") +async def worker_api_get_status(request: Request): + return controller.worker_api_get_status() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--host", type=str, default="localhost") + parser.add_argument("--port", type=int, default=21001) + parser.add_argument("--dispatch-method", type=str, choices=["lottery", "shortest_queue"], default="shortest_queue") + args = parser.parse_args() + logger.info(f"args: {args}") + + controller = Controller(args.dispatch_method) + uvicorn.run(app, host=args.host, port=args.port, log_level="info") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/examples/extreme_ironing.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/examples/extreme_ironing.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf1071a1fbfa904309335e3521cecbcec341b37f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/examples/extreme_ironing.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a54caa21bc513ed25c8ca7f5747555c05dfd4e33f6a3cf5c08b3d9138a4da1d9 +size 62587 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/examples/waterview.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/examples/waterview.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ea03ee6fa60f4025999012b817e674984c706cd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/examples/waterview.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d092764cc9f21b9bc535ff5284b5add4d8256148bab1bc2f5b5ab3fd32759a36 +size 95499 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/gradio_multi_image.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/gradio_multi_image.py new file mode 100644 index 0000000000000000000000000000000000000000..ca0e4206f343247c24b205544ce38102dce2adfb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/gradio_multi_image.py @@ -0,0 +1,448 @@ +import argparse +import datetime +import json +import os +import time + +import gradio as gr +import requests + +from llava.conversation import default_conversation, conv_templates, SeparatorStyle +from llava.constants import LOGDIR +from llava.utils import build_logger, server_error_msg, violates_moderation, moderation_msg +import hashlib + + +logger = build_logger("gradio_web_server", "gradio_web_server.log") + +headers = {"User-Agent": "LLaVA Client"} + +no_change_btn = gr.Button.update() +enable_btn = gr.Button.update(interactive=True) +disable_btn = gr.Button.update(interactive=False) + +priority = { + "vicuna-13b": "aaaaaaa", + "koala-13b": "aaaaaab", +} + + +def get_conv_log_filename(): + t = datetime.datetime.now() + name = os.path.join(LOGDIR, f"{t.year}-{t.month:02d}-{t.day:02d}-conv.json") + return name + + +def get_model_list(): + ret = requests.post(args.controller_url + "/refresh_all_workers") + assert ret.status_code == 200 + ret = requests.post(args.controller_url + "/list_models") + models = ret.json()["models"] + models.sort(key=lambda x: priority.get(x, x)) + logger.info(f"Models: {models}") + return models + + +get_window_url_params = """ +function() { + const params = new URLSearchParams(window.location.search); + url_params = Object.fromEntries(params); + console.log(url_params); + return url_params; + } +""" + + +def load_demo(url_params, request: gr.Request): + logger.info(f"load_demo. ip: {request.client.host}. params: {url_params}") + + dropdown_update = gr.Dropdown.update(visible=True) + if "model" in url_params: + model = url_params["model"] + if model in models: + dropdown_update = gr.Dropdown.update(value=model, visible=True) + + state = default_conversation.copy() + return (state, dropdown_update, gr.Chatbot.update(visible=True), gr.Textbox.update(visible=True), gr.Button.update(visible=True), gr.Row.update(visible=True), gr.Accordion.update(visible=True)) + + +def load_demo_refresh_model_list(request: gr.Request): + logger.info(f"load_demo. ip: {request.client.host}") + models = get_model_list() + state = default_conversation.copy() + return ( + state, + gr.Dropdown.update(choices=models, value=models[0] if len(models) > 0 else ""), + gr.Chatbot.update(visible=True), + gr.Textbox.update(visible=True), + gr.Button.update(visible=True), + gr.Row.update(visible=True), + gr.Accordion.update(visible=True), + ) + + +def vote_last_response(state, vote_type, model_selector, request: gr.Request): + with open(get_conv_log_filename(), "a") as fout: + data = { + "tstamp": round(time.time(), 4), + "type": vote_type, + "model": model_selector, + "state": state.dict(), + "ip": request.client.host, + } + fout.write(json.dumps(data) + "\n") + + +def upvote_last_response(state, model_selector, request: gr.Request): + logger.info(f"upvote. ip: {request.client.host}") + vote_last_response(state, "upvote", model_selector, request) + return ("",) + (disable_btn,) * 3 + + +def downvote_last_response(state, model_selector, request: gr.Request): + logger.info(f"downvote. ip: {request.client.host}") + vote_last_response(state, "downvote", model_selector, request) + return ("",) + (disable_btn,) * 3 + + +def flag_last_response(state, model_selector, request: gr.Request): + logger.info(f"flag. ip: {request.client.host}") + vote_last_response(state, "flag", model_selector, request) + return ("",) + (disable_btn,) * 3 + + +def regenerate(state, image_process_mode, request: gr.Request): + logger.info(f"regenerate. ip: {request.client.host}") + state.messages[-1][-1] = None + prev_human_msg = state.messages[-2] + if type(prev_human_msg[1]) in (tuple, list): + prev_human_msg[1] = (*prev_human_msg[1][:2], image_process_mode) + state.skip_next = False + return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5 + + +def clear_history(request: gr.Request): + logger.info(f"clear_history. ip: {request.client.host}") + state = default_conversation.copy() + return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5 + + +def add_text(state, text, image, image2, image_process_mode, request: gr.Request): + logger.info(f"add_text. ip: {request.client.host}. len: {len(text)}") + if len(text) <= 0 and image is None: + state.skip_next = True + return (state, state.to_gradio_chatbot(), "", None) + (no_change_btn,) * 5 + if args.moderate: + flagged = violates_moderation(text) + if flagged: + state.skip_next = True + return (state, state.to_gradio_chatbot(), moderation_msg, None) + (no_change_btn,) * 5 + + text = text[:3072] # Hard cut-off + images = [x for x in [image, image2] if x is not None] + num_images = len(images) + if num_images > 0: + text = text.replace("", "").strip() + text = text[: 3072 - 512 * num_images] + text = "\n" * num_images + text + text = (text, images, image_process_mode) + if len(state.get_images(return_pil=True)) > 0: + state = default_conversation.copy() + state.append_message(state.roles[0], text) + state.append_message(state.roles[1], None) + state.skip_next = False + return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5 + + +def http_bot(state, model_selector, temperature, top_p, max_new_tokens, request: gr.Request): + logger.info(f"http_bot. ip: {request.client.host}") + start_tstamp = time.time() + model_name = model_selector + + if state.skip_next: + # This generate call is skipped due to invalid inputs + yield (state, state.to_gradio_chatbot()) + (no_change_btn,) * 5 + return + + if len(state.messages) == state.offset + 2: + # First round of conversation + if "llava" in model_name.lower(): + if "llama-2" in model_name.lower(): + if "sharegpt" in model_name.lower(): + if "mmtag" in model_name.lower(): + template_name = "v1_mmtag" + elif "plain" in model_name.lower() and "finetune" not in model_name.lower(): + template_name = "v1_mmtag" + else: + template_name = "llava_v1" + else: + if "mmtag" in model_name.lower(): + template_name = "llava_llama_2_mmtag" + elif "simple" in model_name.lower(): + template_name = "llava_llama_2_simple" + elif "plain" in model_name.lower() and "finetune" not in model_name.lower(): + template_name = "llava_llama_2_mmtag" + elif "simple" in model_name.lower(): + template_name = "llava_llama_2_simple" + else: + template_name = "llava_llama_2" + elif "v1" in model_name.lower(): + if "mmtag" in model_name.lower(): + template_name = "v1_mmtag" + elif "plain" in model_name.lower() and "finetune" not in model_name.lower(): + template_name = "v1_mmtag" + else: + template_name = "llava_v1" + elif "mpt" in model_name.lower(): + template_name = "mpt" + else: + if "mmtag" in model_name.lower(): + template_name = "v0_mmtag" + elif "plain" in model_name.lower() and "finetune" not in model_name.lower(): + template_name = "v0_mmtag" + else: + template_name = "llava_v0" + elif "mpt" in model_name.lower(): + template_name = "mpt_text" + elif "llama-2" in model_name.lower(): + if "sharegpt" in model_name.lower(): + template_name = "vicuna_v1" + else: + template_name = "llama_2" + else: + template_name = "vicuna_v1" + new_state = conv_templates[template_name].copy() + new_state.append_message(new_state.roles[0], state.messages[-2][1]) + new_state.append_message(new_state.roles[1], None) + state = new_state + + # Query worker address + controller_url = args.controller_url + ret = requests.post(controller_url + "/get_worker_address", json={"model": model_name}) + worker_addr = ret.json()["address"] + logger.info(f"model_name: {model_name}, worker_addr: {worker_addr}") + + # No available worker + if worker_addr == "": + state.messages[-1][-1] = server_error_msg + yield (state, state.to_gradio_chatbot(), disable_btn, disable_btn, disable_btn, enable_btn, enable_btn) + return + + # Construct prompt + prompt = state.get_prompt() + + all_images = state.get_images(return_pil=True) + all_image_hash = [hashlib.md5(image.tobytes()).hexdigest() for image in all_images] + for image, hash in zip(all_images, all_image_hash): + t = datetime.datetime.now() + filename = os.path.join(LOGDIR, "serve_images", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{hash}.jpg") + if not os.path.isfile(filename): + os.makedirs(os.path.dirname(filename), exist_ok=True) + image.save(filename) + + # Make requests + pload = { + "model": model_name, + "prompt": prompt, + "temperature": float(temperature), + "top_p": float(top_p), + "max_new_tokens": min(int(max_new_tokens), 1536), + "stop": state.sep if state.sep_style in [SeparatorStyle.SINGLE, SeparatorStyle.MPT] else state.sep2, + "images": f"List of {len(state.get_images())} images: {all_image_hash}", + } + logger.info(f"==== request ====\n{pload}") + + pload["images"] = state.get_images() + + state.messages[-1][-1] = "▌" + yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5 + + try: + # Stream output + response = requests.post(worker_addr + "/worker_generate_stream", headers=headers, json=pload, stream=True, timeout=10) + for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"): + if chunk: + data = json.loads(chunk.decode()) + if data["error_code"] == 0: + output = data["text"][len(prompt) :].strip() + state.messages[-1][-1] = output + "▌" + yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5 + else: + output = data["text"] + f" (error_code: {data['error_code']})" + state.messages[-1][-1] = output + yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn) + return + time.sleep(0.03) + except requests.exceptions.RequestException as e: + state.messages[-1][-1] = server_error_msg + yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn) + return + + state.messages[-1][-1] = state.messages[-1][-1][:-1] + yield (state, state.to_gradio_chatbot()) + (enable_btn,) * 5 + + finish_tstamp = time.time() + logger.info(f"{output}") + + with open(get_conv_log_filename(), "a") as fout: + data = { + "tstamp": round(finish_tstamp, 4), + "type": "chat", + "model": model_name, + "start": round(start_tstamp, 4), + "finish": round(start_tstamp, 4), + "state": state.dict(), + "images": all_image_hash, + "ip": request.client.host, + } + fout.write(json.dumps(data) + "\n") + + +title_markdown = """ +# 🌋 LLaVA: Large Language and Vision Assistant +[[Project Page](https://llava-vl.github.io)] [[Code](https://github.com/haotian-liu/LLaVA)] [[Model](https://github.com/haotian-liu/LLaVA/blob/main/docs/MODEL_ZOO.md)] | 📚 [[LLaVA](https://arxiv.org/abs/2304.08485)] [[LLaVA-v1.5](https://arxiv.org/abs/2310.03744)] +""" + +tos_markdown = """ +### Terms of use +By using this service, users are required to agree to the following terms: +The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research. +Please click the "Flag" button if you get any inappropriate answer! We will collect those to keep improving our moderator. +For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality. +""" + + +learn_more_markdown = """ +### License +The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) of LLaMA, [Terms of Use](https://openai.com/policies/terms-of-use) of the data generated by OpenAI, and [Privacy Practices](https://chrome.google.com/webstore/detail/sharegpt-share-your-chatg/daiacboceoaocpibfodeljbdfacokfjb) of ShareGPT. Please contact us if you find any potential violation. +""" + +block_css = """ + +#buttons button { + min-width: min(120px,100%); +} + +#chatbot img { + display: inline-block; +} + +""" + + +def build_demo(embed_mode): + textbox = gr.Textbox(show_label=False, placeholder="Enter text and press ENTER", container=False) + with gr.Blocks(title="LLaVA", theme=gr.themes.Default(), css=block_css) as demo: + state = gr.State() + + if not embed_mode: + gr.Markdown(title_markdown) + + with gr.Row(): + with gr.Column(scale=3): + with gr.Row(elem_id="model_selector_row"): + model_selector = gr.Dropdown(choices=models, value=models[0] if len(models) > 0 else "", interactive=True, show_label=False, container=False) + + with gr.Row(elem_id="images"): + imagebox = gr.Image(type="pil") + imagebox_2 = gr.Image(type="pil") + image_process_mode = gr.Radio(["Crop", "Resize", "Pad", "Default"], value="Default", label="Preprocess for non-square image", visible=False) + + cur_dir = os.path.dirname(os.path.abspath(__file__)) + gr.Examples( + examples=[ + [f"{cur_dir}/examples/extreme_ironing.jpg", "What is unusual about this image?"], + [f"{cur_dir}/examples/waterview.jpg", "What are the things I should be cautious about when I visit here?"], + ], + inputs=[imagebox, textbox], + ) + + with gr.Accordion("Parameters", open=False, visible=False) as parameter_row: + temperature = gr.Slider( + minimum=0.0, + maximum=1.0, + value=0.2, + step=0.1, + interactive=True, + label="Temperature", + ) + top_p = gr.Slider( + minimum=0.0, + maximum=1.0, + value=0.7, + step=0.1, + interactive=True, + label="Top P", + ) + max_output_tokens = gr.Slider( + minimum=0, + maximum=1024, + value=512, + step=64, + interactive=True, + label="Max output tokens", + ) + + with gr.Column(scale=8): + chatbot = gr.Chatbot(elem_id="chatbot", label="LLaVA Chatbot", visible=False, height=550) + with gr.Row(): + with gr.Column(scale=8): + textbox.render() + with gr.Column(scale=1, min_width=50): + submit_btn = gr.Button(value="Submit", visible=False) + with gr.Row(visible=False) as button_row: + upvote_btn = gr.Button(value="👍 Upvote", interactive=False) + downvote_btn = gr.Button(value="👎 Downvote", interactive=False) + flag_btn = gr.Button(value="⚠️ Flag", interactive=False) + # stop_btn = gr.Button(value="⏹️ Stop Generation", interactive=False) + regenerate_btn = gr.Button(value="🔄 Regenerate", interactive=False) + clear_btn = gr.Button(value="🗑️ Clear", interactive=False) + + if not embed_mode: + gr.Markdown(tos_markdown) + gr.Markdown(learn_more_markdown) + url_params = gr.JSON(visible=False) + + # Register listeners + btn_list = [upvote_btn, downvote_btn, flag_btn, regenerate_btn, clear_btn] + upvote_btn.click(upvote_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn]) + downvote_btn.click(downvote_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn]) + flag_btn.click(flag_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn]) + regenerate_btn.click(regenerate, [state, image_process_mode], [state, chatbot, textbox, imagebox, imagebox_2] + btn_list).then(http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list) + clear_btn.click(clear_history, None, [state, chatbot, textbox, imagebox, imagebox_2] + btn_list) + + textbox.submit(add_text, [state, textbox, imagebox, imagebox_2, image_process_mode], [state, chatbot, textbox, imagebox, imagebox_2] + btn_list).then( + http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list + ) + submit_btn.click(add_text, [state, textbox, imagebox, imagebox_2, image_process_mode], [state, chatbot, textbox, imagebox, imagebox_2] + btn_list).then( + http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list + ) + + if args.model_list_mode == "once": + demo.load(load_demo, [url_params], [state, model_selector, chatbot, textbox, submit_btn, button_row, parameter_row], _js=get_window_url_params) + elif args.model_list_mode == "reload": + demo.load(load_demo_refresh_model_list, None, [state, model_selector, chatbot, textbox, submit_btn, button_row, parameter_row]) + else: + raise ValueError(f"Unknown model list mode: {args.model_list_mode}") + + return demo + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--host", type=str, default="0.0.0.0") + parser.add_argument("--port", type=int) + parser.add_argument("--controller-url", type=str, default="http://localhost:21001") + parser.add_argument("--concurrency-count", type=int, default=8) + parser.add_argument("--model-list-mode", type=str, default="once", choices=["once", "reload"]) + parser.add_argument("--share", action="store_true") + parser.add_argument("--moderate", action="store_true") + parser.add_argument("--embed", action="store_true") + args = parser.parse_args() + logger.info(f"args: {args}") + + models = get_model_list() + + logger.info(args) + demo = build_demo(args.embed) + demo.queue(concurrency_count=args.concurrency_count, status_update_rate=10, api_open=False).launch(server_name=args.host, server_port=args.port, share=args.share) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/gradio_web_server.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/gradio_web_server.py new file mode 100644 index 0000000000000000000000000000000000000000..4070dfaa3861b5460df57d02add37ecdf5067595 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/gradio_web_server.py @@ -0,0 +1,442 @@ +import argparse +import datetime +import json +import os +import time + +import gradio as gr +import requests + +from llava.conversation import default_conversation, conv_templates, SeparatorStyle +from llava.constants import LOGDIR +from llava.utils import build_logger, server_error_msg, violates_moderation, moderation_msg +import hashlib + + +logger = build_logger("gradio_web_server", "gradio_web_server.log") + +headers = {"User-Agent": "LLaVA Client"} + +no_change_btn = gr.Button.update() +enable_btn = gr.Button.update(interactive=True) +disable_btn = gr.Button.update(interactive=False) + +priority = { + "vicuna-13b": "aaaaaaa", + "koala-13b": "aaaaaab", +} + + +def get_conv_log_filename(): + t = datetime.datetime.now() + name = os.path.join(LOGDIR, f"{t.year}-{t.month:02d}-{t.day:02d}-conv.json") + return name + + +def get_model_list(): + ret = requests.post(args.controller_url + "/refresh_all_workers") + assert ret.status_code == 200 + ret = requests.post(args.controller_url + "/list_models") + models = ret.json()["models"] + models.sort(key=lambda x: priority.get(x, x)) + logger.info(f"Models: {models}") + return models + + +get_window_url_params = """ +function() { + const params = new URLSearchParams(window.location.search); + url_params = Object.fromEntries(params); + console.log(url_params); + return url_params; + } +""" + + +def load_demo(url_params, request: gr.Request): + logger.info(f"load_demo. ip: {request.client.host}. params: {url_params}") + + dropdown_update = gr.Dropdown.update(visible=True) + if "model" in url_params: + model = url_params["model"] + if model in models: + dropdown_update = gr.Dropdown.update(value=model, visible=True) + + state = default_conversation.copy() + return state, dropdown_update + + +def load_demo_refresh_model_list(request: gr.Request): + logger.info(f"load_demo. ip: {request.client.host}") + models = get_model_list() + state = default_conversation.copy() + dropdown_update = gr.Dropdown.update(choices=models, value=models[0] if len(models) > 0 else "") + return state, dropdown_update + + +def vote_last_response(state, vote_type, model_selector, request: gr.Request): + with open(get_conv_log_filename(), "a") as fout: + data = { + "tstamp": round(time.time(), 4), + "type": vote_type, + "model": model_selector, + "state": state.dict(), + "ip": request.client.host, + } + fout.write(json.dumps(data) + "\n") + + +def upvote_last_response(state, model_selector, request: gr.Request): + logger.info(f"upvote. ip: {request.client.host}") + vote_last_response(state, "upvote", model_selector, request) + return ("",) + (disable_btn,) * 3 + + +def downvote_last_response(state, model_selector, request: gr.Request): + logger.info(f"downvote. ip: {request.client.host}") + vote_last_response(state, "downvote", model_selector, request) + return ("",) + (disable_btn,) * 3 + + +def flag_last_response(state, model_selector, request: gr.Request): + logger.info(f"flag. ip: {request.client.host}") + vote_last_response(state, "flag", model_selector, request) + return ("",) + (disable_btn,) * 3 + + +def regenerate(state, image_process_mode, request: gr.Request): + logger.info(f"regenerate. ip: {request.client.host}") + state.messages[-1][-1] = None + prev_human_msg = state.messages[-2] + if type(prev_human_msg[1]) in (tuple, list): + prev_human_msg[1] = (*prev_human_msg[1][:2], image_process_mode) + state.skip_next = False + return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5 + + +def clear_history(request: gr.Request): + logger.info(f"clear_history. ip: {request.client.host}") + state = default_conversation.copy() + return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5 + + +def add_text(state, text, image, image_process_mode, request: gr.Request): + logger.info(f"add_text. ip: {request.client.host}. len: {len(text)}") + if len(text) <= 0 and image is None: + state.skip_next = True + return (state, state.to_gradio_chatbot(), "", None) + (no_change_btn,) * 5 + if args.moderate: + flagged = violates_moderation(text) + if flagged: + state.skip_next = True + return (state, state.to_gradio_chatbot(), moderation_msg, None) + (no_change_btn,) * 5 + + text = text[:1536] # Hard cut-off + if image is not None: + text = text[:1200] # Hard cut-off for images + if "" not in text: + # text = '' + text + text = text + "\n" + text = (text, image, image_process_mode) + if len(state.get_images(return_pil=True)) > 0: + state = default_conversation.copy() + state.append_message(state.roles[0], text) + state.append_message(state.roles[1], None) + state.skip_next = False + return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5 + + +def http_bot(state, model_selector, temperature, top_p, max_new_tokens, request: gr.Request, template_name=None): + logger.info(f"http_bot. ip: {request.client.host}") + start_tstamp = time.time() + model_name = model_selector + + if state.skip_next: + # This generate call is skipped due to invalid inputs + yield (state, state.to_gradio_chatbot()) + (no_change_btn,) * 5 + return + + if len(state.messages) == state.offset + 2: + # First round of conversation + if "llava" in model_name.lower(): + if "llama-2" in model_name.lower(): + template_name = "llava_llama_2" + elif "mistral" in model_name.lower() or "mixtral" in model_name.lower(): + if "orca" in model_name.lower(): + template_name = "mistral_orca" + elif "hermes" in model_name.lower(): + template_name = "mistral_direct" + else: + template_name = "mistral_instruct" + elif "zephyr" in model_name.lower(): + template_name = "mistral_zephyr" + elif "hermes" in model_name.lower(): + template_name = "mistral_direct" + elif "v1" in model_name.lower(): + if "mmtag" in model_name.lower(): + template_name = "llava_v1_mmtag" + elif "plain" in model_name.lower() and "finetune" not in model_name.lower(): + template_name = "llava_v1_mmtag" + else: + template_name = "llava_v1" + elif "mpt" in model_name.lower(): + template_name = "mpt" + else: + if "mmtag" in model_name.lower(): + template_name = "v0_plain" + elif "plain" in model_name.lower() and "finetune" not in model_name.lower(): + template_name = "v0_plain" + else: + template_name = "llava_v0" + elif "mistral" in model_name.lower() or "mixtral" in model_name.lower(): + if "orca" in model_name.lower(): + template_name = "mistral_orca" + elif "hermes" in model_name.lower(): + template_name = "mistral_direct" + else: + template_name = "mistral_instruct" + elif "hermes" in model_name.lower(): + template_name = "mistral_direct" + elif "zephyr" in model_name.lower(): + template_name = "mistral_zephyr" + elif "mpt" in model_name: + template_name = "mpt_text" + elif "llama-2" in model_name: + template_name = "llama_2" + else: + template_name = "vicuna_v1" + new_state = conv_templates[template_name].copy() + new_state.append_message(new_state.roles[0], state.messages[-2][1]) + new_state.append_message(new_state.roles[1], None) + state = new_state + + # Query worker address + controller_url = args.controller_url + ret = requests.post(controller_url + "/get_worker_address", json={"model": model_name}) + worker_addr = ret.json()["address"] + logger.info(f"model_name: {model_name}, worker_addr: {worker_addr}") + + # No available worker + if worker_addr == "": + state.messages[-1][-1] = server_error_msg + yield (state, state.to_gradio_chatbot(), disable_btn, disable_btn, disable_btn, enable_btn, enable_btn) + return + + # Construct prompt + prompt = state.get_prompt() + + all_images = state.get_images(return_pil=True) + all_image_hash = [hashlib.md5(image.tobytes()).hexdigest() for image in all_images] + for image, hash in zip(all_images, all_image_hash): + t = datetime.datetime.now() + filename = os.path.join(LOGDIR, "serve_images", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{hash}.jpg") + if not os.path.isfile(filename): + os.makedirs(os.path.dirname(filename), exist_ok=True) + image.save(filename) + + # Make requests + pload = { + "model": model_name, + "prompt": prompt, + "temperature": float(temperature), + "top_p": float(top_p), + "max_new_tokens": min(int(max_new_tokens), 1536), + "stop": state.sep if state.sep_style in [SeparatorStyle.SINGLE, SeparatorStyle.MPT] else state.sep2, + "images": f"List of {len(state.get_images())} images: {all_image_hash}", + } + logger.info(f"==== request ====\n{pload}") + + pload["images"] = state.get_images() + + state.messages[-1][-1] = "▌" + yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5 + + try: + # Stream output + response = requests.post(worker_addr + "/worker_generate_stream", headers=headers, json=pload, stream=True, timeout=100) + last_print_time = time.time() + for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"): + if chunk: + data = json.loads(chunk.decode()) + if data["error_code"] == 0: + output = data["text"][len(prompt) :].strip() + state.messages[-1][-1] = output + "▌" + if time.time() - last_print_time > 0.05: + last_print_time = time.time() + yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5 + else: + output = data["text"] + f" (error_code: {data['error_code']})" + state.messages[-1][-1] = output + yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn) + return + time.sleep(0.03) + except requests.exceptions.RequestException as e: + state.messages[-1][-1] = server_error_msg + yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn) + return + + state.messages[-1][-1] = state.messages[-1][-1][:-1] + yield (state, state.to_gradio_chatbot()) + (enable_btn,) * 5 + + finish_tstamp = time.time() + logger.info(f"{output}") + + with open(get_conv_log_filename(), "a") as fout: + data = { + "tstamp": round(finish_tstamp, 4), + "type": "chat", + "model": model_name, + "start": round(start_tstamp, 4), + "finish": round(start_tstamp, 4), + "state": state.dict(), + "images": all_image_hash, + "ip": request.client.host, + } + fout.write(json.dumps(data) + "\n") + + +title_markdown = """ +# 🌋 LLaVA: Large Language and Vision Assistant +[[Project Page](https://llava-vl.github.io)] [[Code](https://github.com/haotian-liu/LLaVA)] [[Model](https://github.com/haotian-liu/LLaVA/blob/main/docs/MODEL_ZOO.md)] | 📚 [[LLaVA](https://arxiv.org/abs/2304.08485)] [[LLaVA-v1.5](https://arxiv.org/abs/2310.03744)] +""" + +tos_markdown = """ +### Terms of use +By using this service, users are required to agree to the following terms: +The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research. +Please click the "Flag" button if you get any inappropriate answer! We will collect those to keep improving our moderator. +For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality. +""" + + +learn_more_markdown = """ +### License +The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) of LLaMA, [Terms of Use](https://openai.com/policies/terms-of-use) of the data generated by OpenAI, and [Privacy Practices](https://chrome.google.com/webstore/detail/sharegpt-share-your-chatg/daiacboceoaocpibfodeljbdfacokfjb) of ShareGPT. Please contact us if you find any potential violation. +""" + +block_css = """ + +#buttons button { + min-width: min(120px,100%); +} + +""" + + +def build_demo(embed_mode): + textbox = gr.Textbox(show_label=False, placeholder="Enter text and press ENTER", container=False) + with gr.Blocks(title="LLaVA", theme=gr.themes.Default(), css=block_css) as demo: + state = gr.State() + + if not embed_mode: + gr.Markdown(title_markdown) + + with gr.Row(): + with gr.Column(scale=3): + with gr.Row(elem_id="model_selector_row"): + model_selector = gr.Dropdown(choices=models, value=models[0] if len(models) > 0 else "", interactive=True, show_label=False, container=False) + + imagebox = gr.Image(type="pil") + image_process_mode = gr.Radio(["Crop", "Resize", "Pad", "Default"], value="Default", label="Preprocess for non-square image", visible=False) + + cur_dir = os.path.dirname(os.path.abspath(__file__)) + gr.Examples( + examples=[ + [f"{cur_dir}/examples/extreme_ironing.jpg", "What is unusual about this image?"], + [f"{cur_dir}/examples/waterview.jpg", "What are the things I should be cautious about when I visit here?"], + ], + inputs=[imagebox, textbox], + ) + + with gr.Accordion("Parameters", open=False) as parameter_row: + temperature = gr.Slider( + minimum=0.0, + maximum=1.0, + value=0.2, + step=0.1, + interactive=True, + label="Temperature", + ) + top_p = gr.Slider( + minimum=0.0, + maximum=1.0, + value=0.7, + step=0.1, + interactive=True, + label="Top P", + ) + max_output_tokens = gr.Slider( + minimum=0, + maximum=1024, + value=512, + step=64, + interactive=True, + label="Max output tokens", + ) + + with gr.Column(scale=8): + chatbot = gr.Chatbot(elem_id="chatbot", label="LLaVA Chatbot", height=550) + with gr.Row(): + with gr.Column(scale=8): + textbox.render() + with gr.Column(scale=1, min_width=50): + submit_btn = gr.Button(value="Send", variant="primary") + with gr.Row(elem_id="buttons") as button_row: + upvote_btn = gr.Button(value="👍 Upvote", interactive=False) + downvote_btn = gr.Button(value="👎 Downvote", interactive=False) + flag_btn = gr.Button(value="⚠️ Flag", interactive=False) + # stop_btn = gr.Button(value="⏹️ Stop Generation", interactive=False) + regenerate_btn = gr.Button(value="🔄 Regenerate", interactive=False) + clear_btn = gr.Button(value="🗑️ Clear", interactive=False) + + if not embed_mode: + gr.Markdown(tos_markdown) + gr.Markdown(learn_more_markdown) + url_params = gr.JSON(visible=False) + + # Register listeners + btn_list = [upvote_btn, downvote_btn, flag_btn, regenerate_btn, clear_btn] + upvote_btn.click(upvote_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn], queue=False) + downvote_btn.click(downvote_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn], queue=False) + flag_btn.click(flag_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn], queue=False) + + regenerate_btn.click(regenerate, [state, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list, queue=False).then(http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list) + + clear_btn.click(clear_history, None, [state, chatbot, textbox, imagebox] + btn_list, queue=False) + + textbox.submit(add_text, [state, textbox, imagebox, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list, queue=False).then( + http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list + ) + + submit_btn.click(add_text, [state, textbox, imagebox, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list, queue=False).then( + http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list + ) + + if args.model_list_mode == "once": + demo.load(load_demo, [url_params], [state, model_selector], _js=get_window_url_params, queue=False) + elif args.model_list_mode == "reload": + demo.load(load_demo_refresh_model_list, None, [state, model_selector], queue=False) + else: + raise ValueError(f"Unknown model list mode: {args.model_list_mode}") + + return demo + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--host", type=str, default="0.0.0.0") + parser.add_argument("--port", type=int) + parser.add_argument("--controller-url", type=str, default="http://localhost:21001") + parser.add_argument("--concurrency-count", type=int, default=10) + parser.add_argument("--model-list-mode", type=str, default="once", choices=["once", "reload"]) + parser.add_argument("--share", action="store_true") + parser.add_argument("--moderate", action="store_true") + parser.add_argument("--embed", action="store_true") + args = parser.parse_args() + logger.info(f"args: {args}") + + models = get_model_list() + + logger.info(args) + demo = build_demo(args.embed) + demo.queue(concurrency_count=args.concurrency_count, api_open=False).launch(server_name=args.host, server_port=args.port, share=args.share) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/model_worker.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/model_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..cd2256189a5c281bf5bfc54fdb043d4081abde5f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/model_worker.py @@ -0,0 +1,271 @@ +""" +A model worker executes the model. +""" + +import argparse +import asyncio +import json +import time +import threading +import uuid + +from fastapi import FastAPI, Request, BackgroundTasks +from fastapi.responses import StreamingResponse +import requests +import torch +import uvicorn +from functools import partial + +from llava.constants import WORKER_HEART_BEAT_INTERVAL +from llava.utils import build_logger, server_error_msg, pretty_print_semaphore +from llava.model.builder import load_pretrained_model +from llava.mm_utils import process_images, load_image_from_base64, tokenizer_image_token, KeywordsStoppingCriteria +from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN +from transformers import TextIteratorStreamer +from threading import Thread + + +GB = 1 << 30 + +worker_id = str(uuid.uuid4())[:6] +logger = build_logger("model_worker", f"model_worker_{worker_id}.log") +global_counter = 0 + +model_semaphore = None + + +def heart_beat_worker(controller): + + while True: + time.sleep(WORKER_HEART_BEAT_INTERVAL) + controller.send_heart_beat() + + +class ModelWorker: + def __init__(self, controller_addr, worker_addr, worker_id, no_register, model_path, model_base, model_name, load_8bit, load_4bit): + self.controller_addr = controller_addr + self.worker_addr = worker_addr + self.worker_id = worker_id + if model_path.endswith("/"): + model_path = model_path[:-1] + if model_name is None: + model_paths = model_path.split("/") + if model_paths[-1].startswith("checkpoint-"): + self.model_name = model_paths[-2] + "_" + model_paths[-1] + else: + self.model_name = model_paths[-1] + else: + self.model_name = model_name + + logger.info(f"Loading the model {self.model_name} on worker {worker_id} ...") + self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(model_path, model_base, self.model_name, load_8bit, load_4bit) + self.is_multimodal = "llava" in self.model_name.lower() + + if not no_register: + self.register_to_controller() + self.heart_beat_thread = threading.Thread(target=heart_beat_worker, args=(self,)) + self.heart_beat_thread.start() + + def register_to_controller(self): + logger.info("Register to controller") + + url = self.controller_addr + "/register_worker" + data = {"worker_name": self.worker_addr, "check_heart_beat": True, "worker_status": self.get_status()} + r = requests.post(url, json=data) + assert r.status_code == 200 + + def send_heart_beat(self): + logger.info(f"Send heart beat. Models: {[self.model_name]}. " f"Semaphore: {pretty_print_semaphore(model_semaphore)}. " f"global_counter: {global_counter}") + + url = self.controller_addr + "/receive_heart_beat" + + while True: + try: + ret = requests.post(url, json={"worker_name": self.worker_addr, "queue_length": self.get_queue_length()}, timeout=5) + exist = ret.json()["exist"] + break + except requests.exceptions.RequestException as e: + logger.error(f"heart beat error: {e}") + time.sleep(5) + + if not exist: + self.register_to_controller() + + def get_queue_length(self): + if model_semaphore is None: + return 0 + else: + return args.limit_model_concurrency - model_semaphore._value + (len(model_semaphore._waiters) if model_semaphore._waiters is not None else 0) + + def get_status(self): + return { + "model_names": [self.model_name], + "speed": 1, + "queue_length": self.get_queue_length(), + } + + @torch.inference_mode() + def generate_stream(self, params): + tokenizer, model, image_processor = self.tokenizer, self.model, self.image_processor + + prompt = params["prompt"] + ori_prompt = prompt + images = params.get("images", None) + num_image_tokens = 0 + if images is not None and len(images) > 0 and self.is_multimodal: + if len(images) > 0: + if len(images) != prompt.count(DEFAULT_IMAGE_TOKEN): + raise ValueError("Number of images does not match number of tokens in prompt") + + images = [load_image_from_base64(image) for image in images] + image_sizes = [image.size for image in images] + images = process_images(images, image_processor, model.config) + + if type(images) is list: + images = [image.to(self.model.device, dtype=torch.float16) for image in images] + else: + images = images.to(self.model.device, dtype=torch.float16) + + replace_token = DEFAULT_IMAGE_TOKEN + if getattr(self.model.config, "mm_use_im_start_end", False): + replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN + prompt = prompt.replace(DEFAULT_IMAGE_TOKEN, replace_token) + + num_image_tokens = prompt.count(replace_token) * model.get_vision_tower().num_patches + else: + images = None + image_sizes = None + image_args = {"images": images, "image_sizes": image_sizes} + else: + images = None + image_args = {} + + temperature = float(params.get("temperature", 1.0)) + top_p = float(params.get("top_p", 1.0)) + max_context_length = getattr(model.config, "max_position_embeddings", 2048) + max_new_tokens = min(int(params.get("max_new_tokens", 256)), 1024) + stop_str = params.get("stop", None) + do_sample = True if temperature > 0.001 else False + + input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt").unsqueeze(0).cuda() + keywords = [stop_str] + stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids) + streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True, timeout=15) + + max_new_tokens = min(max_new_tokens, max_context_length - input_ids.shape[-1] - num_image_tokens) + + if max_new_tokens < 1: + yield json.dumps({"text": ori_prompt + "Exceeds max token length. Please start a new conversation, thanks.", "error_code": 0}).encode() + b"\0" + return + + thread = Thread( + target=model.generate, + kwargs=dict( + inputs=input_ids, + do_sample=do_sample, + temperature=temperature, + top_p=top_p, + max_new_tokens=max_new_tokens, + streamer=streamer, + # stopping_criteria=[stopping_criteria], + use_cache=True, + **image_args, + ), + ) + thread.start() + + start_time = time.time() + generated_text = ori_prompt + for new_text in streamer: + generated_text += new_text + if generated_text.endswith(stop_str): + generated_text = generated_text[: -len(stop_str)] + yield json.dumps({"text": generated_text, "error_code": 0}).encode() + b"\0" + + end_time = time.time() + + new_generated = generated_text[len(ori_prompt) :] + new_generated_tokens = tokenizer(new_generated).input_ids + token_per_second = len(new_generated_tokens) / (end_time - start_time) + print(f"token_per_second: {token_per_second}") + + def generate_stream_gate(self, params): + try: + for x in self.generate_stream(params): + yield x + except ValueError as e: + print("Caught ValueError:", e) + ret = { + "text": server_error_msg, + "error_code": 1, + } + yield json.dumps(ret).encode() + b"\0" + except torch.cuda.CudaError as e: + print("Caught torch.cuda.CudaError:", e) + ret = { + "text": server_error_msg, + "error_code": 1, + } + yield json.dumps(ret).encode() + b"\0" + except Exception as e: + print("Caught Unknown Error", e) + ret = { + "text": server_error_msg, + "error_code": 1, + } + yield json.dumps(ret).encode() + b"\0" + + +app = FastAPI() + + +def release_model_semaphore(fn=None): + model_semaphore.release() + if fn is not None: + fn() + + +@app.post("/worker_generate_stream") +async def generate_stream(request: Request): + global model_semaphore, global_counter + global_counter += 1 + params = await request.json() + + if model_semaphore is None: + model_semaphore = asyncio.Semaphore(args.limit_model_concurrency) + await model_semaphore.acquire() + worker.send_heart_beat() + generator = worker.generate_stream_gate(params) + background_tasks = BackgroundTasks() + background_tasks.add_task(partial(release_model_semaphore, fn=worker.send_heart_beat)) + return StreamingResponse(generator, background=background_tasks) + + +@app.post("/worker_get_status") +async def get_status(request: Request): + return worker.get_status() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--host", type=str, default="localhost") + parser.add_argument("--port", type=int, default=21002) + parser.add_argument("--worker-address", type=str, default="http://localhost:21002") + parser.add_argument("--controller-address", type=str, default="http://localhost:21001") + parser.add_argument("--model-path", type=str, default="facebook/opt-350m") + parser.add_argument("--model-base", type=str, default=None) + parser.add_argument("--model-name", type=str) + parser.add_argument("--multi-modal", action="store_true", help="Multimodal mode is automatically detected with model name, please make sure `llava` is included in the model path.") + parser.add_argument("--limit-model-concurrency", type=int, default=5) + parser.add_argument("--stream-interval", type=int, default=1) + parser.add_argument("--no-register", action="store_true") + parser.add_argument("--load-8bit", action="store_true") + parser.add_argument("--load-4bit", action="store_true") + args = parser.parse_args() + logger.info(f"args: {args}") + + if args.multi_modal: + logger.warning("Multimodal mode is automatically detected with model name, please make sure `llava` is included in the model path.") + + worker = ModelWorker(args.controller_address, args.worker_address, worker_id, args.no_register, args.model_path, args.model_base, args.model_name, args.load_8bit, args.load_4bit) + uvicorn.run(app, host=args.host, port=args.port, log_level="info") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/register_worker.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/register_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..2c2c40295e0351f25709ba25554c9329f15bf0d2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/register_worker.py @@ -0,0 +1,26 @@ +""" +Manually register workers. + +Usage: +python3 -m fastchat.serve.register_worker --controller http://localhost:21001 --worker-name http://localhost:21002 +""" + +import argparse + +import requests + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--controller-address", type=str) + parser.add_argument("--worker-name", type=str) + parser.add_argument("--check-heart-beat", action="store_true") + args = parser.parse_args() + + url = args.controller_address + "/register_worker" + data = { + "worker_name": args.worker_name, + "check_heart_beat": args.check_heart_beat, + "worker_status": None, + } + r = requests.post(url, json=data) + assert r.status_code == 200 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/sglang_worker.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/sglang_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..09c047f48ea6d8774b30d1c5df159d877edfd742 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/sglang_worker.py @@ -0,0 +1,237 @@ +""" +A model worker executes the model. +""" + +import argparse +import asyncio +from concurrent.futures import ThreadPoolExecutor +import json +import time +import threading +import uuid + +from fastapi import FastAPI, Request, BackgroundTasks +from fastapi.responses import StreamingResponse +import requests +import re +import uvicorn +from functools import partial + +from llava.constants import WORKER_HEART_BEAT_INTERVAL +from llava.utils import build_logger, server_error_msg, pretty_print_semaphore +from llava.model.builder import load_pretrained_model +from llava.mm_utils import process_images, load_image_from_base64, tokenizer_image_token, expand2square +from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN +from transformers import AutoTokenizer + +import sglang as sgl +from sglang.test.test_utils import add_common_sglang_args_and_parse, select_sglang_backend +from sglang.backend.runtime_endpoint import RuntimeEndpoint +from sglang.utils import read_jsonl, dump_state_text +from sglang.lang.interpreter import ProgramState + + +GB = 1 << 30 + +worker_id = str(uuid.uuid4())[:6] +logger = build_logger("model_worker", f"model_worker_{worker_id}.log") +global_counter = 0 + +model_semaphore = None + + +def heart_beat_worker(controller): + while True: + time.sleep(WORKER_HEART_BEAT_INTERVAL) + controller.send_heart_beat() + + +@sgl.function +def pipeline(s, prompt, max_tokens): + for p in prompt: + if type(p) is str: + s += p + else: + s += sgl.image(p) + s += sgl.gen("response", max_tokens=max_tokens) + + +class ModelWorker: + def __init__(self, controller_addr, worker_addr, sgl_endpoint, worker_id, no_register, model_name): + self.controller_addr = controller_addr + self.worker_addr = worker_addr + self.worker_id = worker_id + + # Select backend + backend = RuntimeEndpoint(sgl_endpoint) + sgl.set_default_backend(backend) + model_path = backend.model_info["model_path"] + + if model_path.endswith("/"): + model_path = model_path[:-1] + if model_name is None: + model_paths = model_path.split("/") + if model_paths[-1].startswith("checkpoint-"): + self.model_name = model_paths[-2] + "_" + model_paths[-1] + else: + self.model_name = model_paths[-1] + else: + self.model_name = model_name + + logger.info(f"Loading the SGLANG model {self.model_name} on worker {worker_id} ...") + + if not no_register: + self.register_to_controller() + self.heart_beat_thread = threading.Thread(target=heart_beat_worker, args=(self,)) + self.heart_beat_thread.start() + + def register_to_controller(self): + logger.info("Register to controller") + + url = self.controller_addr + "/register_worker" + data = {"worker_name": self.worker_addr, "check_heart_beat": True, "worker_status": self.get_status()} + r = requests.post(url, json=data) + assert r.status_code == 200 + + def send_heart_beat(self): + logger.info(f"Send heart beat. Models: {[self.model_name]}. " f"Semaphore: {pretty_print_semaphore(model_semaphore)}. " f"global_counter: {global_counter}") + + url = self.controller_addr + "/receive_heart_beat" + + while True: + try: + ret = requests.post(url, json={"worker_name": self.worker_addr, "queue_length": self.get_queue_length()}, timeout=5) + exist = ret.json()["exist"] + break + except requests.exceptions.RequestException as e: + logger.error(f"heart beat error: {e}") + time.sleep(5) + + if not exist: + self.register_to_controller() + + def get_queue_length(self): + if model_semaphore is None: + return 0 + else: + return args.limit_model_concurrency - model_semaphore._value + (len(model_semaphore._waiters) if model_semaphore._waiters is not None else 0) + + def get_status(self): + return { + "model_names": [self.model_name], + "speed": 1, + "queue_length": self.get_queue_length(), + } + + async def generate_stream(self, params): + ori_prompt = prompt = params["prompt"] + images = params.get("images", None) + if images is not None and len(images) > 0: + if len(images) > 0: + if len(images) != prompt.count(DEFAULT_IMAGE_TOKEN): + raise ValueError("Number of images does not match number of tokens in prompt") + + images = [load_image_from_base64(image) for image in images] + # FIXME: hacky padding + images = [expand2square(image, tuple(int(x * 255) for x in [0.48145466, 0.4578275, 0.40821073])) for image in images] + + # FIXME: for image-start/end token + # replace_token = DEFAULT_IMAGE_TOKEN + # if getattr(self.model.config, 'mm_use_im_start_end', False): + # replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN + # prompt = prompt.replace(DEFAULT_IMAGE_TOKEN, replace_token) + prompt = prompt.replace(" " + DEFAULT_IMAGE_TOKEN + "\n", DEFAULT_IMAGE_TOKEN) + prompt_split = prompt.split(DEFAULT_IMAGE_TOKEN) + prompt = [] + for i in range(len(prompt_split)): + prompt.append(prompt_split[i]) + if i < len(images): + prompt.append(images[i]) + else: + prompt = [prompt] + + temperature = float(params.get("temperature", 1.0)) + top_p = float(params.get("top_p", 1.0)) + # max_context_length = getattr(model.config, 'max_position_embeddings', 2048) + max_new_tokens = min(int(params.get("max_new_tokens", 256)), 1024) + stop_str = params.get("stop", None) + stop_str = [stop_str] if stop_str is not None else None + + if max_new_tokens < 1: + yield json.dumps({"text": ori_prompt + "Exceeds max token length. Please start a new conversation, thanks.", "error_code": 0}).encode() + b"\0" + return + + # print(prompt) + state = pipeline.run(prompt, max_new_tokens, temperature=temperature, top_p=top_p, stream=True) + + generated_text = ori_prompt + async for text_outputs in state.text_async_iter(var_name="response"): + generated_text += text_outputs + yield json.dumps({"text": generated_text, "error_code": 0}).encode() + b"\0" + + async def generate_stream_gate(self, params): + try: + async for x in self.generate_stream(params): + yield x + except ValueError as e: + print("Caught ValueError:", e) + ret = { + "text": server_error_msg, + "error_code": 1, + } + yield json.dumps(ret).encode() + b"\0" + except Exception as e: + print("Caught Unknown Error", e) + ret = { + "text": server_error_msg, + "error_code": 1, + } + yield json.dumps(ret).encode() + b"\0" + + +app = FastAPI() + + +def release_model_semaphore(fn=None): + model_semaphore.release() + if fn is not None: + fn() + + +@app.post("/worker_generate_stream") +async def generate_stream(request: Request): + global model_semaphore, global_counter + global_counter += 1 + params = await request.json() + + if model_semaphore is None: + model_semaphore = asyncio.Semaphore(args.limit_model_concurrency) + await model_semaphore.acquire() + worker.send_heart_beat() + generator = worker.generate_stream_gate(params) + background_tasks = BackgroundTasks() + background_tasks.add_task(partial(release_model_semaphore, fn=worker.send_heart_beat)) + return StreamingResponse(generator, background=background_tasks) + + +@app.post("/worker_get_status") +async def get_status(request: Request): + return worker.get_status() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--host", type=str, default="localhost") + parser.add_argument("--port", type=int, default=21002) + parser.add_argument("--worker-address", type=str, default="http://localhost:21002") + parser.add_argument("--controller-address", type=str, default="http://localhost:21001") + parser.add_argument("--model-name", type=str) + parser.add_argument("--sgl-endpoint", type=str) + parser.add_argument("--limit-model-concurrency", type=int, default=5) + parser.add_argument("--stream-interval", type=int, default=1) + parser.add_argument("--no-register", action="store_true") + args = parser.parse_args() + logger.info(f"args: {args}") + + worker = ModelWorker(args.controller_address, args.worker_address, args.sgl_endpoint, worker_id, args.no_register, args.model_name) + uvicorn.run(app, host=args.host, port=args.port, log_level="info") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/test_message.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/test_message.py new file mode 100644 index 0000000000000000000000000000000000000000..45acd534fb23fdc9c85d6dd0575b192cabc0da41 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/serve/test_message.py @@ -0,0 +1,59 @@ +import argparse +import json + +import requests + +from llava.conversation import default_conversation + + +def main(): + if args.worker_address: + worker_addr = args.worker_address + else: + controller_addr = args.controller_address + ret = requests.post(controller_addr + "/refresh_all_workers") + ret = requests.post(controller_addr + "/list_models") + models = ret.json()["models"] + models.sort() + print(f"Models: {models}") + + ret = requests.post(controller_addr + "/get_worker_address", json={"model": args.model_name}) + worker_addr = ret.json()["address"] + print(f"worker_addr: {worker_addr}") + + if worker_addr == "": + return + + conv = default_conversation.copy() + conv.append_message(conv.roles[0], args.message) + prompt = conv.get_prompt() + + headers = {"User-Agent": "LLaVA Client"} + pload = { + "model": args.model_name, + "prompt": prompt, + "max_new_tokens": args.max_new_tokens, + "temperature": 0.7, + "stop": conv.sep, + } + response = requests.post(worker_addr + "/worker_generate_stream", headers=headers, json=pload, stream=True) + + print(prompt.replace(conv.sep, "\n"), end="") + for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False, delimiter=b"\0"): + if chunk: + data = json.loads(chunk.decode("utf-8")) + output = data["text"].split(conv.sep)[-1] + print(output, end="\r") + print("") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--controller-address", type=str, default="http://localhost:21001") + parser.add_argument("--worker-address", type=str) + parser.add_argument("--model-name", type=str, default="facebook/opt-350m") + parser.add_argument("--max-new-tokens", type=int, default=32) + parser.add_argument("--message", type=str, default="Tell me a story with more than 1000 words.") + args = parser.parse_args() + + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llama_flash_attn_monkey_patch.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llama_flash_attn_monkey_patch.py new file mode 100644 index 0000000000000000000000000000000000000000..c88fe34266d5467cf49ba0ad4fbc5f5eeac5c029 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llama_flash_attn_monkey_patch.py @@ -0,0 +1,87 @@ +from typing import Optional, Tuple +import warnings + +import torch + +import transformers +from transformers.models.llama.modeling_llama import apply_rotary_pos_emb, repeat_kv + +try: + from flash_attn.flash_attn_interface import flash_attn_unpadded_qkvpacked_func +except ImportError: + from flash_attn.flash_attn_interface import flash_attn_varlen_qkvpacked_func as flash_attn_unpadded_qkvpacked_func +from flash_attn.bert_padding import unpad_input, pad_input + + +def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.Tensor] = None, + past_key_value: Optional[Tuple[torch.Tensor]] = None, + output_attentions: bool = False, + use_cache: bool = False, + padding_mask: Optional[torch.Tensor] = None, +) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: + if output_attentions: + warnings.warn("Output attentions is not supported for patched `LlamaAttention`, returning `None` instead.") + + bsz, q_len, _ = hidden_states.size() + + query_states = self.q_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + key_states = self.k_proj(hidden_states).view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + value_states = self.v_proj(hidden_states).view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) # shape: (b, num_heads, s, head_dim) + + kv_seq_len = key_states.shape[-2] + if past_key_value is not None: + kv_seq_len += past_key_value[0].shape[-2] + + cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len) + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids) + + if past_key_value is not None: + # reuse k, v + key_states = torch.cat([past_key_value[0], key_states], dim=2) + value_states = torch.cat([past_key_value[1], value_states], dim=2) + + past_key_value = (key_states, value_states) if use_cache else None + + # repeat k/v heads if n_kv_heads < n_heads + key_states = repeat_kv(key_states, self.num_key_value_groups) + value_states = repeat_kv(value_states, self.num_key_value_groups) + + # Transform the data into the format required by flash attention + qkv = torch.stack([query_states, key_states, value_states], dim=2) + qkv = qkv.transpose(1, 3) # shape: [b, s, 3, num_heads, head_dim] + key_padding_mask = attention_mask + + if key_padding_mask is None: + qkv = qkv.reshape(-1, 3, self.num_heads, self.head_dim) + cu_q_lens = torch.arange(0, (bsz + 1) * q_len, step=q_len, dtype=torch.int32, device=qkv.device) + max_s = q_len + output = flash_attn_unpadded_qkvpacked_func(qkv, cu_q_lens, max_s, 0.0, softmax_scale=None, causal=True) + output = output.view(bsz, q_len, -1) + else: + qkv = qkv.reshape(bsz, q_len, -1) + qkv, indices, cu_q_lens, max_s = unpad_input(qkv, key_padding_mask) + qkv = qkv.view(-1, 3, self.num_heads, self.head_dim) + output_unpad = flash_attn_unpadded_qkvpacked_func(qkv, cu_q_lens, max_s, 0.0, softmax_scale=None, causal=True) + output_unpad = output_unpad.reshape(-1, self.num_heads * self.head_dim) + output = pad_input(output_unpad, indices, bsz, q_len) + + return self.o_proj(output), None, past_key_value + + +# Disable the transformation of the attention mask in LlamaModel as the flash attention +# requires the attention mask to be the same as the key_padding_mask +def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length): + # [bsz, seq_len] + return attention_mask + + +def replace_llama_attn_with_flash_attn(): + cuda_major, cuda_minor = torch.cuda.get_device_capability() + if cuda_major < 8: + warnings.warn("Flash attention is only supported on A100 or H100 GPU during training due to head dim > 64 backward." "ref: https://github.com/HazyResearch/flash-attention/issues/190#issuecomment-1523359593") + transformers.models.llama.modeling_llama.LlamaModel._prepare_decoder_attention_mask = _prepare_decoder_attention_mask + transformers.models.llama.modeling_llama.LlamaAttention.forward = forward diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llava_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llava_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..e65473cd088274cc7119d55ba98d0ef7381fb570 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llava_trainer.py @@ -0,0 +1,527 @@ +import os +import torch +import torch.nn as nn +import datetime + +from accelerate import Accelerator +from accelerate.utils import InitProcessGroupKwargs, GradientAccumulationPlugin +from torch.utils.data import Dataset, Sampler, DataLoader + +from trl.trainer import DPOTrainer +from trl.trainer.utils import DPODataCollatorWithPadding + +from transformers import Trainer +from transformers.trainer import is_sagemaker_mp_enabled, get_parameter_names, has_length, ALL_LAYERNORM_LAYERS, logger, is_accelerate_available, is_datasets_available, GradientAccumulationPlugin +from transformers.trainer_utils import seed_worker +from transformers.trainer_pt_utils import get_length_grouped_indices as get_length_grouped_indices_hf +from transformers.trainer_pt_utils import AcceleratorConfig +from typing import List, Optional +from datetime import timedelta + +if is_accelerate_available(): + from accelerate import Accelerator, skip_first_batches, InitProcessGroupKwargs + +if is_datasets_available(): + import datasets + +from llava.utils import rank0_print + + +def maybe_zero_3(param, ignore_status=False, name=None): + from deepspeed import zero + from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus + + if hasattr(param, "ds_id"): + if param.ds_status == ZeroParamStatus.NOT_AVAILABLE: + if not ignore_status: + print(name, "no ignore status") + with zero.GatheredParameters([param]): + param = param.data.detach().cpu().clone() + else: + param = param.detach().cpu().clone() + return param + + +def get_mm_adapter_state_maybe_zero_3(named_params, keys_to_match): + to_return = {k: t for k, t in named_params if any(key_match in k for key_match in keys_to_match)} + to_return = {k: maybe_zero_3(v, ignore_status=True, name=k).cpu() for k, v in to_return.items()} + return to_return + + +def split_to_even_chunks(indices, lengths, num_chunks): + """ + Split a list of indices into `chunks` chunks of roughly equal lengths. + """ + + if len(indices) % num_chunks != 0: + return [indices[i::num_chunks] for i in range(num_chunks)] + + num_indices_per_chunk = len(indices) // num_chunks + + chunks = [[] for _ in range(num_chunks)] + chunks_lengths = [0 for _ in range(num_chunks)] + for index in indices: + shortest_chunk = chunks_lengths.index(min(chunks_lengths)) + chunks[shortest_chunk].append(index) + chunks_lengths[shortest_chunk] += lengths[index] + if len(chunks[shortest_chunk]) == num_indices_per_chunk: + chunks_lengths[shortest_chunk] = float("inf") + + return chunks + + +def get_variable_length_grouped_indices(lengths, batch_size, world_size, megabatch_mult=8, generator=None): + # We need to use torch for the random part as a distributed sampler will set the random seed for torch. + indices = torch.randperm(len(lengths), generator=generator) + sorted_indices = sorted(range(len(lengths)), key=lambda i: lengths[i], reverse=True) + megabatch_size = world_size * batch_size * megabatch_mult + megabatches = [sorted_indices[i : i + megabatch_size] for i in range(0, len(lengths), megabatch_size)] + megabatches = [sorted(megabatch, key=lambda i: indices[i], reverse=True) for megabatch in megabatches] + shuffled_indices = [i for megabatch in megabatches for i in megabatch] + world_batch_size = world_size * batch_size + batches = [shuffled_indices[i : i + world_batch_size] for i in range(0, len(lengths), world_batch_size)] + batch_indices = torch.randperm(len(batches), generator=generator) + batches = [batches[i] for i in batch_indices] + + return [i for batch in batches for i in batch] + + +def get_modality_length_grouped_indices(lengths, batch_size, world_size, generator=None): + """ + Return a list of indices so that each slice of `batch_size` consecutive indices correspond to elements of similar + lengths. To do this, the indices are: + + - randomly permuted + - grouped in mega-batches of size `mega_batch_mult * batch_size` + - reorder by length in each mega-batch + + The result is the concatenation of all mega-batches, with the batch of `batch_size` containing the element of + maximum length placed first, so that an OOM happens sooner rather than later. + """ + + # We need to use torch for the random part as a distributed sampler will set the random seed for torch. + assert all(l != 0 for l in lengths), "Should not have zero length." + if all(l > 0 for l in lengths) or all(l < 0 for l in lengths): + # all samples are in the same modality + return get_length_grouped_indices(lengths, batch_size, world_size, generator=generator) + mm_indices, mm_lengths = zip(*[(i, l) for i, l in enumerate(lengths) if l > 0]) + lang_indices, lang_lengths = zip(*[(i, -l) for i, l in enumerate(lengths) if l < 0]) + + mm_shuffle = [mm_indices[i] for i in get_length_grouped_indices(mm_lengths, batch_size, world_size, generator=None)] + lang_shuffle = [lang_indices[i] for i in get_length_grouped_indices(lang_lengths, batch_size, world_size, generator=None)] + megabatch_size = world_size * batch_size + mm_megabatches = [mm_shuffle[i : i + megabatch_size] for i in range(0, len(mm_shuffle), megabatch_size)] + lang_megabatches = [lang_shuffle[i : i + megabatch_size] for i in range(0, len(lang_shuffle), megabatch_size)] + + last_mm = mm_megabatches[-1] + last_lang = lang_megabatches[-1] + additional_batch = last_mm + last_lang + megabatches = mm_megabatches[:-1] + lang_megabatches[:-1] + megabatch_indices = torch.randperm(len(megabatches), generator=generator) + megabatches = [megabatches[i] for i in megabatch_indices] + + if len(additional_batch) > 0: + megabatches.append(sorted(additional_batch)) + + return [i for megabatch in megabatches for i in megabatch] + + +def get_length_grouped_indices(lengths, batch_size, world_size, generator=None, merge=True): + """ + Return a list of indices so that each slice of `batch_size` consecutive indices correspond to elements of similar + lengths. To do this, the indices are: + + - randomly permuted + - grouped in mega-batches of size `mega_batch_mult * batch_size` + - reorder by length in each mega-batch + + The result is the concatenation of all mega-batches, with the batch of `batch_size` containing the element of + maximum length placed first, so that an OOM happens sooner rather than later. + """ + + # We need to use torch for the random part as a distributed sampler will set the random seed for torch. + indices = torch.randperm(len(lengths), generator=generator) + megabatch_size = world_size * batch_size + megabatches = [indices[i : i + megabatch_size].tolist() for i in range(0, len(lengths), megabatch_size)] + megabatches = [sorted(megabatch, key=lambda i: lengths[i], reverse=True) for megabatch in megabatches] + megabatches = [split_to_even_chunks(megabatch, lengths, world_size) for megabatch in megabatches] + + return [i for megabatch in megabatches for batch in megabatch for i in batch] + + +def get_length_grouped_indices_auto_single(lengths, batch_size, world_size, generator=None): + indices = get_length_grouped_indices_hf(lengths, batch_size * world_size, generator=generator) + + megabatch_size = world_size * batch_size + megabatches = [indices[i : i + megabatch_size] for i in range(0, len(lengths), megabatch_size)] + megabatches = [sorted(megabatch, key=lambda i: lengths[i], reverse=True) for megabatch in megabatches] + megabatches = [split_to_even_chunks(megabatch, lengths, world_size) for megabatch in megabatches] + + # We need to use torch for the random part as a distributed sampler will set the random seed for torch. + batch_indices = torch.randperm(len(megabatches), generator=generator) + megabatches = [megabatches[i] for i in batch_indices] + + return [i for megabatch in megabatches for batch in megabatch for i in batch] + + +def get_modality_length_grouped_indices_auto(lengths, batch_size, world_size, generator=None): + # We need to use torch for the random part as a distributed sampler will set the random seed for torch. + assert all(l != 0 for l in lengths), "Should not have zero length." + if all(l > 0 for l in lengths) or all(l < 0 for l in lengths): + # all samples are in the same modality + return get_length_grouped_indices_auto_single(lengths, batch_size, world_size, generator=generator) + mm_indices, mm_lengths = zip(*[(i, l) for i, l in enumerate(lengths) if l > 0]) + lang_indices, lang_lengths = zip(*[(i, -l) for i, l in enumerate(lengths) if l < 0]) + + mm_shuffle = [mm_indices[i] for i in get_length_grouped_indices_auto_single(mm_lengths, batch_size, world_size, generator=None)] + lang_shuffle = [lang_indices[i] for i in get_length_grouped_indices_auto_single(lang_lengths, batch_size, world_size, generator=None)] + megabatch_size = world_size * batch_size + mm_megabatches = [mm_shuffle[i : i + megabatch_size] for i in range(0, len(mm_shuffle), megabatch_size)] + lang_megabatches = [lang_shuffle[i : i + megabatch_size] for i in range(0, len(lang_shuffle), megabatch_size)] + + last_mm = mm_megabatches[-1] + last_lang = lang_megabatches[-1] + additional_batch = last_mm + last_lang + megabatches = mm_megabatches[:-1] + lang_megabatches[:-1] + megabatch_indices = torch.randperm(len(megabatches), generator=generator) + megabatches = [megabatches[i] for i in megabatch_indices] + + # FIXME: Hard code to avoid last batch mixed with different modalities + # if len(additional_batch) > 0: + # megabatches.append(sorted(additional_batch)) + + return [i for megabatch in megabatches for i in megabatch] + + +class LengthGroupedSampler(Sampler): + r""" + Sampler that samples indices in a way that groups together features of the dataset of roughly the same length while + keeping a bit of randomness. + """ + + def __init__( + self, + batch_size: int, + world_size: int, + lengths: Optional[List[int]] = None, + generator=None, + variable_length: bool = False, + group_by_modality: bool = False, + group_by_modality_auto: bool = False, + ): + if lengths is None: + raise ValueError("Lengths must be provided.") + + self.batch_size = batch_size + self.world_size = world_size + self.lengths = lengths + self.generator = generator + self.variable_length = variable_length + self.group_by_modality = group_by_modality + self.group_by_modality_auto = group_by_modality_auto + + def __len__(self): + return len(self.lengths) + + def __iter__(self): + if self.variable_length: + assert not self.group_by_modality, "Variable length grouping is not supported with modality grouping." + indices = get_variable_length_grouped_indices(self.lengths, self.batch_size, self.world_size, generator=self.generator) + else: + if self.group_by_modality: + indices = get_modality_length_grouped_indices(self.lengths, self.batch_size, self.world_size, generator=self.generator) + elif self.group_by_modality_auto: + indices = get_modality_length_grouped_indices_auto(self.lengths, self.batch_size, self.world_size, generator=self.generator) + else: + indices = get_length_grouped_indices_auto_single(self.lengths, self.batch_size, self.world_size, generator=self.generator) + return iter(indices) + + +class LLaVATrainer(Trainer): + + def create_accelerator_and_postprocess(self): + grad_acc_kwargs = {"num_steps": self.args.gradient_accumulation_steps} + grad_acc_kwargs["sync_with_dataloader"] = False + gradient_accumulation_plugin = GradientAccumulationPlugin(**grad_acc_kwargs) + + accelerator_kwargs = InitProcessGroupKwargs(timeout=timedelta(weeks=52)) + rank0_print("Setting NCCL timeout to INF to avoid running errors.") + + # create accelerator object + self.accelerator = Accelerator( + dispatch_batches=self.args.dispatch_batches, split_batches=self.args.split_batches, deepspeed_plugin=self.args.deepspeed_plugin, gradient_accumulation_plugin=gradient_accumulation_plugin, kwargs_handlers=[accelerator_kwargs] + ) + # some Trainer classes need to use `gather` instead of `gather_for_metrics`, thus we store a flag + self.gather_function = self.accelerator.gather_for_metrics + + # deepspeed and accelerate flags covering both trainer args and accelerate launcher + self.is_deepspeed_enabled = getattr(self.accelerator.state, "deepspeed_plugin", None) is not None + self.is_fsdp_enabled = getattr(self.accelerator.state, "fsdp_plugin", None) is not None + + # post accelerator creation setup + if self.is_fsdp_enabled: + fsdp_plugin = self.accelerator.state.fsdp_plugin + fsdp_plugin.limit_all_gathers = self.args.fsdp_config.get("limit_all_gathers", fsdp_plugin.limit_all_gathers) + if is_accelerate_available("0.23.0"): + fsdp_plugin.activation_checkpointing = self.args.fsdp_config.get("activation_checkpointing", fsdp_plugin.activation_checkpointing) + if fsdp_plugin.activation_checkpointing and self.args.gradient_checkpointing: + raise ValueError("The activation_checkpointing in FSDP config and the gradient_checkpointing in training arg " "can't be set to True simultaneously. Please use FSDP's activation_checkpointing logic " "when using FSDP.") + + if self.is_deepspeed_enabled and getattr(self.args, "hf_deepspeed_config", None) is None: + self.propagate_args_to_deepspeed() + + def _get_train_sampler(self) -> Optional[torch.utils.data.Sampler]: + if self.train_dataset is None or not has_length(self.train_dataset): + return None + + if self.args.group_by_length: + lengths = self.train_dataset.lengths + return LengthGroupedSampler( + # self.args.train_batch_size * self.args.gradient_accumulation_steps, # TODO: seems that we should not have gradient_accumulation_steps + self.args.train_batch_size, + # world_size=self.args.world_size, + world_size=self.args.world_size * self.args.gradient_accumulation_steps, # TODO: seems that this may work? + lengths=lengths, + ) + elif self.args.group_by_modality_length: + lengths = self.train_dataset.modality_lengths + return LengthGroupedSampler( + # self.args.train_batch_size * self.args.gradient_accumulation_steps, # TODO: seems that we should not have gradient_accumulation_steps + self.args.train_batch_size, + # world_size=self.args.world_size, + world_size=self.args.world_size * self.args.gradient_accumulation_steps, # TODO: seems that this may work? + lengths=lengths, + group_by_modality=True, + ) + elif self.args.group_by_modality_length_auto: + lengths = self.train_dataset.modality_lengths + return LengthGroupedSampler( + # self.args.train_batch_size * self.args.gradient_accumulation_steps, # TODO: seems that we should not have gradient_accumulation_steps + self.args.train_batch_size, + # world_size=self.args.world_size, + world_size=self.args.world_size * self.args.gradient_accumulation_steps, # TODO: seems that this may work? + lengths=lengths, + group_by_modality_auto=True, + ) + elif self.args.group_by_varlen: + lengths = self.train_dataset.lengths + return LengthGroupedSampler( + self.args.train_batch_size * self.args.gradient_accumulation_steps, + # self.args.train_batch_size, # TODO: seems that we should have gradient_accumulation_steps + # world_size=self.args.world_size, + world_size=self.args.world_size * self.args.gradient_accumulation_steps, # TODO: seems that this may work? + lengths=lengths, + variable_length=True, + ) + else: + return super()._get_train_sampler() + + def get_train_dataloader(self) -> DataLoader: + """ + Returns the training [`~torch.utils.data.DataLoader`]. + + Will use no sampler if `train_dataset` does not implement `__len__`, a random sampler (adapted to distributed + training if necessary) otherwise. + + Subclass and override this method if you want to inject some custom behavior. + """ + if self.train_dataset is None: + raise ValueError("Trainer: training requires a train_dataset.") + + train_dataset = self.train_dataset + data_collator = self.data_collator + if is_datasets_available() and isinstance(train_dataset, datasets.Dataset): + train_dataset = self._remove_unused_columns(train_dataset, description="training") + else: + data_collator = self._get_collator_with_removed_columns(data_collator, description="training") + + dataloader_params = { + "batch_size": self._train_batch_size, + "collate_fn": data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "persistent_workers": self.args.dataloader_persistent_workers, + } + + if not isinstance(train_dataset, torch.utils.data.IterableDataset): + dataloader_params["sampler"] = self._get_train_sampler() + dataloader_params["drop_last"] = self.args.dataloader_drop_last + dataloader_params["worker_init_fn"] = seed_worker + dataloader_params["prefetch_factor"] = self.args.dataloader_num_workers * 2 if self.args.dataloader_num_workers != 0 else None + + dataloader = self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params)) + + return dataloader + + def create_optimizer(self): + """ + Setup the optimizer. + + We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the + Trainer's init through `optimizers`, or subclass and override this method in a subclass. + """ + if is_sagemaker_mp_enabled(): + return super().create_optimizer() + + opt_model = self.model + + if self.optimizer is None: + decay_parameters = get_parameter_names(opt_model, ALL_LAYERNORM_LAYERS) + decay_parameters = [name for name in decay_parameters if "bias" not in name] + lr_mapper = {} + if self.args.mm_projector_lr is not None: + lr_mapper["mm_projector"] = self.args.mm_projector_lr + if self.args.mm_vision_tower_lr is not None: + lr_mapper["vision_tower"] = self.args.mm_vision_tower_lr + if len(lr_mapper) > 0: + special_lr_parameters = [name for name, _ in opt_model.named_parameters() if any(module_keyword in name for module_keyword in lr_mapper)] + optimizer_grouped_parameters = [ + { + "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n not in special_lr_parameters and p.requires_grad)], + "weight_decay": self.args.weight_decay, + }, + { + "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n not in special_lr_parameters and p.requires_grad)], + "weight_decay": 0.0, + }, + ] + for module_keyword, lr in lr_mapper.items(): + module_parameters = [name for name, _ in opt_model.named_parameters() if module_keyword in name] + optimizer_grouped_parameters.extend( + [ + { + "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in module_parameters and p.requires_grad)], + "weight_decay": self.args.weight_decay, + "lr": lr, + }, + { + "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in module_parameters and p.requires_grad)], + "weight_decay": 0.0, + "lr": lr, + }, + ] + ) + else: + optimizer_grouped_parameters = [ + { + "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and p.requires_grad)], + "weight_decay": self.args.weight_decay, + }, + { + "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and p.requires_grad)], + "weight_decay": 0.0, + }, + ] + + optimizer_cls, optimizer_kwargs = Trainer.get_optimizer_cls_and_kwargs(self.args) + + self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs) + if optimizer_cls.__name__ == "Adam8bit": + import bitsandbytes + + manager = bitsandbytes.optim.GlobalOptimManager.get_instance() + + skipped = 0 + for module in opt_model.modules(): + if isinstance(module, nn.Embedding): + skipped += sum({p.data_ptr(): p.numel() for p in module.parameters()}.values()) + logger.info(f"skipped {module}: {skipped/2**20}M params") + manager.register_module_override(module, "weight", {"optim_bits": 32}) + logger.debug(f"bitsandbytes: will optimize {module} in fp32") + logger.info(f"skipped: {skipped/2**20}M params") + + return self.optimizer + + def _save_checkpoint(self, model, trial, metrics=None): + if getattr(self.args, "tune_mm_mlp_adapter", False) or ( + hasattr(self.args, "mm_tunable_parts") and (len(self.args.mm_tunable_parts.split(",")) == 1 and ("mm_mlp_adapter" in self.args.mm_tunable_parts or "mm_vision_resampler" in self.args.mm_tunable_parts)) + ): + from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR + + checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}" + + run_dir = self._get_output_dir(trial=trial) + output_dir = os.path.join(run_dir, checkpoint_folder) + + # Only save Adapter + keys_to_match = ["mm_projector", "vision_resampler"] + if getattr(self.args, "use_im_start_end", False): + keys_to_match.extend(["embed_tokens", "embed_in"]) + + weight_to_save = get_mm_adapter_state_maybe_zero_3(self.model.named_parameters(), keys_to_match) + + if self.args.local_rank == 0 or self.args.local_rank == -1: + self.model.config.save_pretrained(output_dir) + torch.save(weight_to_save, os.path.join(output_dir, f"mm_projector.bin")) + else: + super(LLaVATrainer, self)._save_checkpoint(model, trial, metrics) + + def _save(self, output_dir: Optional[str] = None, state_dict=None): + if getattr(self.args, "tune_mm_mlp_adapter", False): + pass + else: + super(LLaVATrainer, self)._save(output_dir, state_dict) + + +class LLaVADPOTrainer(DPOTrainer): + def _get_train_sampler(self) -> Optional[torch.utils.data.Sampler]: + if self.train_dataset is None or not has_length(self.train_dataset): + return None + + if self.args.group_by_modality_length: + lengths = self.train_dataset.modality_lengths + return LengthGroupedSampler( + # self.args.train_batch_size * self.args.gradient_accumulation_steps, # TODO: seems that we should not have gradient_accumulation_steps + self.args.train_batch_size, + world_size=self.args.world_size, + lengths=lengths, + group_by_modality=True, + ) + else: + return super()._get_train_sampler() + + def _save_checkpoint(self, model, trial, metrics=None): + if getattr(self.args, "tune_mm_mlp_adapter", False) or ( + hasattr(self.args, "mm_tunable_parts") and (len(self.args.mm_tunable_parts.split(",")) == 1 and ("mm_mlp_adapter" in self.args.mm_tunable_parts or "mm_vision_resampler" in self.args.mm_tunable_parts)) + ): + from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR + + checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}" + + run_dir = self._get_output_dir(trial=trial) + output_dir = os.path.join(run_dir, checkpoint_folder) + + # Only save Adapter + keys_to_match = ["mm_projector", "vision_resampler"] + if getattr(self.args, "use_im_start_end", False): + keys_to_match.extend(["embed_tokens", "embed_in"]) + + weight_to_save = get_mm_adapter_state_maybe_zero_3(self.model.named_parameters(), keys_to_match) + + if self.args.local_rank == 0 or self.args.local_rank == -1: + self.model.config.save_pretrained(output_dir) + torch.save(weight_to_save, os.path.join(output_dir, f"mm_projector.bin")) + else: + # super(LLaVADPOTrainer, self)._save_checkpoint(model, trial, metrics) + # print(type(model)) + # from transformers.modeling_utils import unwrap_model + # print(type(unwrap_model(model))) + # print(unwrap_model(model).config) + if self.args.lora_enable: + from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR + + checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}" + run_dir = self._get_output_dir(trial=trial) + output_dir = os.path.join(run_dir, checkpoint_folder) + from transformers.modeling_utils import unwrap_model + + unwrapped_model = unwrap_model(model) + self.save_my_lora_ckpt(output_dir, self.args, unwrapped_model) + else: + super(LLaVADPOTrainer, self)._save_checkpoint(model, trial, metrics) + + def _save(self, output_dir: Optional[str] = None, state_dict=None): + if getattr(self.args, "tune_mm_mlp_adapter", False): + pass + else: + super(LLaVADPOTrainer, self)._save(output_dir, state_dict) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llava_trainer_eval.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llava_trainer_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..e82225852569674e9eea2cb8912153fba76b33fe --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/llava_trainer_eval.py @@ -0,0 +1,76 @@ +import json +import subprocess + +from llava.train.llava_trainer import LLaVATrainer + + +class LLaVAEvalTrainer(LLaVATrainer): + def evaluate(self, evaluate_args): + cmd = f"accelerate launch --num_processes {evaluate_args.eval_num_processes} -m lmms_eval \ + --model {evaluate_args.model} \ + --model_args {evaluate_args.model_args} \ + --tasks {evaluate_args.task_names} \ + --batch_size {evaluate_args.batch_size} \ + --log_samples_suffix {evaluate_args.log_samples_suffix} \ + --output_path {evaluate_args.output_path}" + if evaluate_args.limit: + cmd += f" --limit {evaluate_args.limit}" + if evaluate_args.num_fewshot: + cmd += f" --num_fewshot {evaluate_args.num_fewshot}" + if evaluate_args.gen_kwargs != "": + cmd += f" --gen_kwargs {evaluate_args.gen_kwargs}" + if evaluate_args.log_samples: + cmd += f" --log_samples" + else: + assert False, "Please log samples so that the result can be parsed" + results = subprocess.run([cmd], shell=True, capture_output=True, text=True) + try: + result_file_index_start = results.stdout.index("Saved samples to ") + result_file_index_end = results.stdout.index(f".json") + result_file_index_start += len("Saved samples to ") + file = results.stdout[result_file_index_start:result_file_index_end] + except: + result_file_index_start = results.stderr.index("Saved samples to ") + result_file_index_end = results.stderr.index(f".json") + result_file_index_start += len("Saved samples to ") + file = results.stderr[result_file_index_start:result_file_index_end] + file = file.split("/")[:-1] + file = "/".join(file) + "/results.json" + with open(file, "r") as f: + lmms_eval_results = json.load(f) + result_dict = {} + tasks_list = evaluate_args.task_names.split(",") + for task in tasks_list: + task_results = lmms_eval_results["results"][task] + for k, v in task_results.items(): + if k != "alias" and "stderr" not in k: + metric = k.split(",")[0] + result_dict[f"{task}_{metric}"] = v + return result_dict + + """def evaluate(self, evaluate_args): + initialize_tasks() + tasks_list = evaluate_args.task_names.split(",") + result_dict = {} + results = evaluator.simple_evaluate( + model=evaluate_args.model, + model_args=evaluate_args.model_args, + tasks=tasks_list, + num_fewshot=evaluate_args.num_fewshot, + batch_size=evaluate_args.batch_size, + device=evaluate_args.device, + limit=evaluate_args.limit, + check_integrity=evaluate_args.check_integrity, + show_task_to_terminal=evaluate_args.show_task_to_terminal, + log_samples=evaluate_args.log_samples, + gen_kwargs=evaluate_args.gen_kwargs, + cli_args=evaluate_args, + ) + for task in tasks_list: + task_results = results["results"][task] + for k,v in task_results.items(): + if k != "alias" and "stderr" not in k: + metric = k.split(",")[0] + result_dict[f"{task}_{metric}"] = v + + return result_dict""" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train.py new file mode 100644 index 0000000000000000000000000000000000000000..c342d88e9f425ae42196ade0dbb8382f938ef772 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train.py @@ -0,0 +1,1721 @@ +# Adopted from https://github.com/lm-sys/FastChat. Below is the original copyright: +# Adopted from tatsu-lab@stanford_alpaca. Below is the original copyright: +# Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import ast +import os +import copy +from dataclasses import dataclass, field +import json +import logging +import pathlib +from typing import Dict, Optional, Sequence, List +from PIL import Image, ImageFile +from packaging import version +import numpy as np + +import time +import random +import yaml +import math +import re +import torch + +import transformers +import tokenizers +import deepspeed + +from transformers import AutoConfig +from torch.utils.data import Dataset +from llava.constants import IGNORE_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN, IMAGE_TOKEN_INDEX +from llava.train.llava_trainer import LLaVATrainer + +from llava import conversation as conversation_lib +from llava.model import * +from llava.mm_utils import process_highres_image, process_anyres_image, process_highres_image_crop_split, tokenizer_image_token +from llava.utils import rank0_print, process_video_with_pyav, process_video_with_decord + +torch.multiprocessing.set_sharing_strategy("file_system") + +ImageFile.LOAD_TRUNCATED_IMAGES = True +local_rank = None + +IS_TOKENIZER_GREATER_THAN_0_14 = version.parse(tokenizers.__version__) >= version.parse("0.14") + + +@dataclass +class ModelArguments: + model_name_or_path: Optional[str] = field(default="facebook/opt-125m") + model_class_name: Optional[str] = field(default=None, metadata={"help": "Used to init model class, format is XXXXForCausalLM. e.g. currently XXXX is chosen from LlavaLlama, LlavaMixtral, LlavaMistral, Llama"}) + + mm_tunable_parts: Optional[str] = field( + default=None, metadata={"help": 'Could be "mm_mlp_adapter", "mm_vision_resampler", "mm_vision_tower,mm_mlp_adapter,mm_language_model", "mm_vision_tower,mm_mlp_adapter,mm_language_model", "mm_mlp_adapter,mm_language_model"'} + ) + # deciding which part of the multimodal model to tune, will overwrite other previous settings + + version: Optional[str] = field(default="v0") + freeze_backbone: bool = field(default=False) + tune_mm_mlp_adapter: bool = field(default=False) + tune_mm_vision_resampler: bool = field(default=False) + vision_tower: Optional[str] = field(default=None) + vision_tower_pretrained: Optional[str] = field(default=None) # default to the last layer + + unfreeze_mm_vision_tower: bool = field(default=False) + unfreeze_language_model: bool = field(default=False) + mm_vision_select_layer: Optional[int] = field(default=-1) # default to the last layer + pretrain_mm_mlp_adapter: Optional[str] = field(default=None) + mm_projector_type: Optional[str] = field(default="linear") + mm_use_im_start_end: bool = field(default=False) + mm_use_im_patch_token: bool = field(default=True) + mm_patch_merge_type: Optional[str] = field(default="flat") + mm_vision_select_feature: Optional[str] = field(default="patch") + mm_resampler_type: Optional[str] = field(default=None) + mm_mask_drop_mode: str = field(default="fixed") + mm_mask_drop_skip_percentage: float = field(default=0.0) + mm_mask_drop_ratio: float = field(default=0.25) + mm_mask_drop_ratio_upper: Optional[float] = field(default=None) + mm_mask_drop_ratio_lower: Optional[float] = field(default=None) + mm_spatial_pool_stride: Optional[int] = field(default=None) + mm_spatial_pool_mode: str = field(default="bilinear") + mm_spatial_pool_out_channels: Optional[int] = field(default=None) + mm_perceiver_depth: Optional[int] = field(default=3) + mm_perceiver_latents: Optional[int] = field(default=32) + mm_perceiver_ff_mult: Optional[float] = field(default=4) + mm_perceiver_pretrained: Optional[str] = field(default=None) + mm_qformer_depth: Optional[int] = field(default=3) + mm_qformer_latents: Optional[int] = field(default=32) + mm_qformer_pretrained: Optional[str] = field(default=None) + + rope_scaling_factor: Optional[float] = field(default=None) + rope_scaling_type: Optional[str] = field(default=None) + + s2: Optional[bool] = field(default=False) + s2_scales: Optional[str] = field(default="336,672,1008") + + use_pos_skipping: Optional[bool] = field(default=False) + pos_skipping_range: Optional[int] = field(default=4096) + + + mm_newline_position: Optional[str] = field(default="grid") + delay_load: Optional[bool] = field(default=True) + add_faster_video: Optional[bool] = field(default=False) + faster_token_stride: Optional[int] = field(default=10) + + + +@dataclass +class DataArguments: + data_path: str = field(default=None, metadata={"help": "Path to the training data, in llava's instruction.json format. Supporting multiple json files via /path/to/{a,b,c}.json"}) + lazy_preprocess: bool = False + is_multimodal: bool = False + early_mix_text: bool = False + image_folder: Optional[str] = field(default=None) + image_aspect_ratio: str = "square" + image_grid_pinpoints: Optional[str] = field(default=None) + image_crop_resolution: Optional[int] = field(default=None) + image_split_resolution: Optional[int] = field(default=None) + + video_folder: Optional[str] = field(default=None) + video_fps: Optional[int] = field(default=1) + frames_upbound: Optional[int] = field(default=0) + add_time_instruction: Optional[bool] = field(default=False) + force_sample: Optional[bool] = field(default=False) + + +@dataclass +class TrainingArguments(transformers.TrainingArguments): + cache_dir: Optional[str] = field(default=None) + optim: str = field(default="adamw_torch") + remove_unused_columns: bool = field(default=False) + freeze_mm_mlp_adapter: bool = field(default=False) + freeze_mm_vision_resampler: bool = field(default=False) + mpt_attn_impl: Optional[str] = field(default="triton") + model_max_length: int = field( + default=4096, + metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."}, + ) + double_quant: bool = field(default=True, metadata={"help": "Compress the quantization statistics through double quantization."}) + quant_type: str = field(default="nf4", metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}) + bits: int = field(default=16, metadata={"help": "How many bits to use."}) + lora_enable: bool = False + lora_r: int = 64 + lora_alpha: int = 16 + lora_dropout: float = 0.05 + lora_weight_path: str = "" + lora_bias: str = "none" + mm_projector_lr: Optional[float] = None + mm_vision_tower_lr: Optional[float] = None + group_by_varlen: bool = field(default=False) + group_by_modality_length: bool = field(default=False) + group_by_modality_length_auto: bool = field(default=False) + auto_find_batch_size: bool = field(default=False) + gradient_checkpointing: bool = field(default=True) + verbose_logging: bool = field(default=False) + attn_implementation: str = field(default="flash_attention_2", metadata={"help": "Use transformers attention implementation."}) + + +# @dataclass +# class EvaluationArguments: +# eval_num_processes: int = field(default=1) +# task_names: str = field(default=None) +# model: str = field(default="llava") +# model_args: Optional[str] = field(default=None) +# num_fewshot: Optional[int] = field(default=None) +# batch_size: int = field(default=1) +# device: Optional[str] = field(default=None) +# limit: Optional[int] = field(default=None) +# check_integrity: Optional[bool] = field(default=False) +# show_task_to_terminal: Optional[bool] = field(default=False) +# log_samples: Optional[bool] = field(default=True) +# gen_kwargs: Optional[str] = field(default="") +# log_samples_suffix: Optional[str] = field(default="") +# output_path: Optional[str] = field(default="./logs/") + + +def maybe_zero_3(param, ignore_status=False, name=None): + from deepspeed import zero + from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus + + if hasattr(param, "ds_id"): + if param.ds_status == ZeroParamStatus.NOT_AVAILABLE: + if not ignore_status: + logging.warning(f"{name}: param.ds_status != ZeroParamStatus.NOT_AVAILABLE: {param.ds_status}") + with zero.GatheredParameters([param]): + param = param.data.detach().cpu().clone() + else: + param = param.detach().cpu().clone() + return param + + +# Borrowed from peft.utils.get_peft_model_state_dict +def get_peft_state_maybe_zero_3(named_params, bias): + if bias == "none": + to_return = {k: t for k, t in named_params if "lora_" in k} + elif bias == "all": + to_return = {k: t for k, t in named_params if "lora_" in k or "bias" in k} + elif bias == "lora_only": + to_return = {} + maybe_lora_bias = {} + lora_bias_names = set() + for k, t in named_params: + if "lora_" in k: + to_return[k] = t + bias_name = k.split("lora_")[0] + "bias" + lora_bias_names.add(bias_name) + elif "bias" in k: + maybe_lora_bias[k] = t + for k, t in maybe_lora_bias: + if bias_name in lora_bias_names: + to_return[bias_name] = t + else: + raise NotImplementedError + to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()} + return to_return + + +def get_peft_state_non_lora_maybe_zero_3(named_params, require_grad_only=True): + to_return = {k: t for k, t in named_params if "lora_" not in k} + if require_grad_only: + to_return = {k: t for k, t in to_return.items() if t.requires_grad} + to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()} + return to_return + + +def get_mm_adapter_state_maybe_zero_3(named_params, keys_to_match): + to_return = {k: t for k, t in named_params if any(key_match in k for key_match in keys_to_match)} + to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()} + return to_return + + +def find_all_linear_names(model): + cls = torch.nn.Linear + lora_module_names = set() + multimodal_keywords = ["mm_projector", "vision_tower", "vision_resampler"] + for name, module in model.named_modules(): + if any(mm_keyword in name for mm_keyword in multimodal_keywords): + continue + if isinstance(module, cls): + names = name.split(".") + lora_module_names.add(names[0] if len(names) == 1 else names[-1]) + + if "lm_head" in lora_module_names: # needed for 16-bit + lora_module_names.remove("lm_head") + return list(lora_module_names) + + +def safe_save_model_for_hf_trainer(trainer: transformers.Trainer, output_dir: str): + """Collects the state dict and dump to disk.""" + if hasattr(trainer.args, "tune_mm_mlp_adapter") and trainer.args.tune_mm_mlp_adapter: + check_only_save_mm_adapter_tunnable = True + # only has mm_mlp_adapter and mm_vision_resampler in the tuneable parts + elif hasattr(trainer.args, "mm_tunable_parts") and (len(trainer.args.mm_tunable_parts.split(",")) == 1 and ("mm_mlp_adapter" in trainer.args.mm_tunable_parts or "mm_vision_resampler" in trainer.args.mm_tunable_parts)): + check_only_save_mm_adapter_tunnable = True + else: + check_only_save_mm_adapter_tunnable = False + + trainer.accelerator.wait_for_everyone() + torch.cuda.synchronize() + rank0_print(f"Only save projectors: {check_only_save_mm_adapter_tunnable}") + if check_only_save_mm_adapter_tunnable: + # Only save Adapter + keys_to_match = ["mm_projector", "vision_resampler"] + if getattr(trainer.args, "use_im_start_end", False): + keys_to_match.extend(["embed_tokens", "embed_in"]) + + weight_to_save = get_mm_adapter_state_maybe_zero_3(trainer.model.named_parameters(), keys_to_match) + trainer.model.config.save_pretrained(output_dir) + + current_folder = output_dir.split("/")[-1] + parent_folder = os.path.dirname(output_dir) + if trainer.args.local_rank == 0 or trainer.args.local_rank == -1: + if current_folder.startswith("checkpoint-"): + mm_projector_folder = os.path.join(parent_folder, "mm_projector") + os.makedirs(mm_projector_folder, exist_ok=True) + torch.save(weight_to_save, os.path.join(mm_projector_folder, f"{current_folder}.bin")) + else: + torch.save(weight_to_save, os.path.join(output_dir, f"mm_projector.bin")) + return + + if trainer.deepspeed: + trainer.save_model(output_dir) + return + + state_dict = trainer.model.state_dict() + if trainer.args.should_save: + cpu_state_dict = {key: value.cpu() for key, value in state_dict.items()} + del state_dict + trainer._save(output_dir, state_dict=cpu_state_dict) # noqa + + +def smart_tokenizer_and_embedding_resize( + special_tokens_dict: Dict, + tokenizer: transformers.PreTrainedTokenizer, + model: transformers.PreTrainedModel, +): + """Resize tokenizer and embedding. + + Note: This is the unoptimized version that may make your embedding size not be divisible by 64. + """ + num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict) + model.resize_token_embeddings(len(tokenizer)) + + if num_new_tokens > 0: + input_embeddings = model.get_input_embeddings().weight.data + output_embeddings = model.get_output_embeddings().weight.data + + input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True) + output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True) + + input_embeddings[-num_new_tokens:] = input_embeddings_avg + output_embeddings[-num_new_tokens:] = output_embeddings_avg + + +def _tokenize_fn(strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer) -> Dict: + """Tokenize a list of strings.""" + tokenized_list = [ + tokenizer( + text, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ) + for text in strings + ] + input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list] + input_ids_lens = labels_lens = [tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item() for tokenized in tokenized_list] + return dict( + input_ids=input_ids, + labels=labels, + input_ids_lens=input_ids_lens, + labels_lens=labels_lens, + ) + + +def _mask_targets(target, tokenized_lens, speakers): + # cur_idx = 0 + cur_idx = tokenized_lens[0] + tokenized_lens = tokenized_lens[1:] + target[:cur_idx] = IGNORE_INDEX + for tokenized_len, speaker in zip(tokenized_lens, speakers): + if speaker == "human": + target[cur_idx + 2 : cur_idx + tokenized_len] = IGNORE_INDEX + cur_idx += tokenized_len + + +def _add_speaker_and_signal(header, source, get_conversation=True): + """Add speaker and start/end signal on each round.""" + BEGIN_SIGNAL = "### " + END_SIGNAL = "\n" + conversation = header + for sentence in source: + from_str = sentence["from"] + if from_str.lower() == "human": + from_str = conversation_lib.default_conversation.roles[0] + elif from_str.lower() == "gpt": + from_str = conversation_lib.default_conversation.roles[1] + else: + from_str = "unknown" + sentence["value"] = BEGIN_SIGNAL + from_str + ": " + sentence["value"] + END_SIGNAL + if get_conversation: + conversation += sentence["value"] + conversation += BEGIN_SIGNAL + return conversation + + +def preprocess_multimodal(sources: Sequence[str], data_args: DataArguments) -> Dict: + is_multimodal = data_args.is_multimodal + if not is_multimodal: + return sources + + for source in sources: + for sentence in source: + # TODO maybe this should be changed for interleaved data? + # if DEFAULT_IMAGE_TOKEN in sentence["value"] and not sentence["value"].startswith(DEFAULT_IMAGE_TOKEN): + # only check for num_im=1 + num_im = len(re.findall(DEFAULT_IMAGE_TOKEN, sentence["value"])) + if num_im == 1 and DEFAULT_IMAGE_TOKEN in sentence["value"] and not sentence["value"].startswith(DEFAULT_IMAGE_TOKEN): + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, "").strip() + sentence["value"] = DEFAULT_IMAGE_TOKEN + "\n" + sentence["value"] + sentence["value"] = sentence["value"].strip() + if "mmtag" in conversation_lib.default_conversation.version: + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, "" + DEFAULT_IMAGE_TOKEN + "") + replace_token = DEFAULT_IMAGE_TOKEN + if data_args.mm_use_im_start_end: + replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, replace_token) + + # For videoInstruct-100k noisy_data. TODO: Ask Yuanhan to clean the data instead of leaving the noise code here. + sentence["value"] = sentence["value"].replace("QA_GT_caption_based_noisy", "") + + return sources + + +def preprocess_llama_2(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv = conversation_lib.default_conversation.copy() + roles = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + + if has_image: + input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets = input_ids.clone() + + assert conv.sep_style == conversation_lib.SeparatorStyle.LLAMA_2 + + # Mask targets + sep = "[/INST] " + for conversation, target in zip(conversations, targets): + total_len = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds = conversation.split(conv.sep2) + cur_len = 1 + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2 + else: + round_len = len(tokenizer(rou).input_ids) + instruction_len = len(tokenizer(parts[0]).input_ids) - 2 + + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + + cur_len += round_len + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f" (ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_gemma(sources: List[List[Dict[str, str]]], tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv: conversation_lib.Conversation = conversation_lib.default_conversation.copy() + roles: Dict[str, str] = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations: List[str] = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source: List[Dict[str, str]] = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role: str = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + if has_image: + input_ids: torch.Tensor = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids: torch.Tensor = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets: torch.Tensor = input_ids.clone() + assert conv.sep_style == conversation_lib.SeparatorStyle.GEMMA + + # Mask target + sep: str = conv.sep + conv.roles[1] + for conversation, target in zip(conversations, targets): + total_len: int = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds: List[str] = conversation.split(conv.sep) + re_rounds = [] + for conv_idx in range(0, len(rounds), 2): + re_rounds.append(conv.sep.join(rounds[conv_idx : conv_idx + 2])) + + cur_len = 1 # Ignore + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(re_rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep # Re-append sep because split on this + # Now "".join(parts)==rou + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) - 1 # Ignore + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 1 # Ignore + else: + round_len = len(tokenizer(rou).input_ids) - 1 # Ignore + instruction_len = len(tokenizer(parts[0]).input_ids) - 1 # Ignore + + round_len += 2 # sep: \n takes 2 tokens + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + cur_len += round_len + + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + print(f"warning: tokenization mismatch: {cur_len} vs. {total_len}." f" (ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_qwen(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False, max_len=2048, system_message: str = "You are a helpful assistant.") -> Dict: + # roles = {"human": "<|im_start|>user", "gpt": "<|im_start|>assistant"} + roles = {"human": "user", "gpt": "assistant"} + + # Add image tokens to tokenizer as a special tokens + # Use a deepcopy of tokenizer so that we don't modify on the tokenizer + tokenizer = copy.deepcopy(tokenizer) + # When there is actually an image, we add the image tokens as a special token + if has_image: + tokenizer.add_tokens([""], special_tokens=True) + + image_token_index = tokenizer.convert_tokens_to_ids("") + im_start, im_end = tokenizer.additional_special_tokens_ids + # unmask_tokens = ["<|im_start|>", "<|im_start|>", "\n"] + unmask_tokens_idx = [198, im_start, im_end] + nl_tokens = tokenizer("\n").input_ids + + # Reset Qwen chat templates so that it won't include system message every time we apply + chat_template = "{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}" + tokenizer.chat_template = chat_template + + # _system = tokenizer("system").input_ids + nl_tokens + # _user = tokenizer("user").input_ids + nl_tokens + # _assistant = tokenizer("assistant").input_ids + nl_tokens + + # Apply prompt templates + input_ids, targets = [], [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != roles["human"]: + source = source[1:] + + input_id, target = [], [] + + # New version, use apply chat template + # Build system message for each sentence + input_id += tokenizer.apply_chat_template([{"role" : "system", "content" : system_message}]) + target += [IGNORE_INDEX] * len(input_id) + + for conv in source: + # Make sure llava data can load + try: + role = conv["role"] + content = conv["content"] + except: + role = conv["from"] + content = conv["value"] + + role = roles.get(role, role) + + conv = [{"role" : role, "content" : content}] + encode_id = tokenizer.apply_chat_template(conv) + input_id += encode_id + if role in ["user", "system"]: + target += [IGNORE_INDEX] * len(encode_id) + else: + target += encode_id + + + + assert len(input_id) == len(target), f"{len(input_id)} != {len(target)}" + for idx, encode_id in enumerate(input_id): + if encode_id in unmask_tokens_idx: + target[idx] = encode_id + if encode_id == image_token_index: + input_id[idx] = IMAGE_TOKEN_INDEX + input_ids.append(input_id) + targets.append(target) + input_ids = torch.tensor(input_ids, dtype=torch.long) + targets = torch.tensor(targets, dtype=torch.long) + + return dict( + input_ids=input_ids, # tensor(bs x seq_len) + labels=targets, # tensor(bs x seq_len) + ) + + +def preprocess_llama3( + sources, + tokenizer: transformers.PreTrainedTokenizer, + has_image: bool = False, + max_len=2048, + system_message: str = "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.", +) -> Dict: + # roles = {"human": "<|start_header_id|>user<|end_header_id|>", "gpt": "<|start_header_id|>assistant<|end_header_id|>"} + roles = {"human": "user", "gpt": "assistant"} + + # Add image tokens to tokenizer as a special tokens + # Use a deepcopy of tokenizer so that we don't modify on the tokenizer + tokenizer = copy.deepcopy(tokenizer) + # When there is actually an image, we add the image tokens as a special token + if has_image: + tokenizer.add_tokens([""], special_tokens=True) + image_token_index = tokenizer.convert_tokens_to_ids("") + bos_token_id = tokenizer.convert_tokens_to_ids("<|begin_of_text|>") + start_header_id = tokenizer.convert_tokens_to_ids("<|start_header_id|>") + end_header_id = tokenizer.convert_tokens_to_ids("<|end_header_id|>") + eot_id = tokenizer.convert_tokens_to_ids("<|eot_id|>") + + unmask_tokens = ["<|begin_of_text|>", "<|start_header_id|>", "<|end_header_id|>", "<|eot_id|>", "\n\n"] + unmask_tokens_idx = [tokenizer.convert_tokens_to_ids(tok) for tok in unmask_tokens] + + # After update, calling tokenizer of llama3 will + # auto add bos id for the tokens. ヽ(｀⌒´)ﾉ + def safe_tokenizer_llama3(text): + input_ids = tokenizer(text).input_ids + if input_ids[0] == bos_token_id: + input_ids = input_ids[1:] + return input_ids + + nl_tokens = tokenizer.convert_tokens_to_ids("\n\n") + # Apply prompt templates + input_ids, targets = [], [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != roles["human"]: + source = source[1:] + + input_id, target = [], [] + + # New version, use apply chat template + # Build system message for each sentence + input_id += tokenizer.apply_chat_template([{"role" : "system", "content" : system_message}]) + target += [IGNORE_INDEX] * len(input_id) + + for conv in source: + # Make sure llava data can load + try: + role = conv["role"] + content = conv["content"] + except: + role = conv["from"] + content = conv["value"] + + role = roles.get(role, role) + + conv = [{"role" : role, "content" : content}] + # First is bos token we don't need here + encode_id = tokenizer.apply_chat_template(conv)[1:] + input_id += encode_id + if role in ["user", "system"]: + target += [IGNORE_INDEX] * len(encode_id) + else: + target += encode_id + + + + assert len(input_id) == len(target), f"{len(input_id)} != {len(target)}" + for idx, encode_id in enumerate(input_id): + if encode_id in unmask_tokens_idx: + target[idx] = encode_id + if encode_id == image_token_index: + input_id[idx] = IMAGE_TOKEN_INDEX + input_ids.append(input_id) + targets.append(target) + input_ids = torch.tensor(input_ids, dtype=torch.long) + targets = torch.tensor(targets, dtype=torch.long) + + return dict( + input_ids=input_ids, # tensor(bs x seq_len) + labels=targets, # tensor(bs x seq_len) + ) + + +def preprocess_v1(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv = conversation_lib.default_conversation.copy() + roles = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + + if has_image: + input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets = input_ids.clone() + + assert conv.sep_style == conversation_lib.SeparatorStyle.TWO + + # Mask targets + sep = conv.sep + conv.roles[1] + ": " + for conversation, target in zip(conversations, targets): + total_len = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds = conversation.split(conv.sep2) + cur_len = 1 + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2 + else: + round_len = len(tokenizer(rou).input_ids) + instruction_len = len(tokenizer(parts[0]).input_ids) - 2 + + if i != 0 and not tokenizer.legacy and IS_TOKENIZER_GREATER_THAN_0_14: + round_len -= 1 + instruction_len -= 1 + + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + + cur_len += round_len + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f" (ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_mpt(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv = conversation_lib.default_conversation.copy() + roles = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + + if has_image: + input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets = input_ids.clone() + assert conv.sep_style == conversation_lib.SeparatorStyle.MPT + + # Mask targets + sep = conv.sep + conv.roles[1] + for conversation, target in zip(conversations, targets): + total_len = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds = conversation.split(conv.sep) + re_rounds = [conv.sep.join(rounds[:3])] # system + user + gpt + for conv_idx in range(3, len(rounds), 2): + re_rounds.append(conv.sep.join(rounds[conv_idx : conv_idx + 2])) # user + gpt + cur_len = 1 + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(re_rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 1 + else: + round_len = len(tokenizer(rou).input_ids) + instruction_len = len(tokenizer(parts[0]).input_ids) - 1 + + if i != 0 and getattr(tokenizer, "legacy", False) and IS_TOKENIZER_GREATER_THAN_0_14: + round_len += 1 + instruction_len += 1 + + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + + cur_len += round_len + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f"(#turns={len(re_rounds)} ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_plain( + sources: Sequence[str], + tokenizer: transformers.PreTrainedTokenizer, +) -> Dict: + # add end signal and concatenate together + conversations = [] + for source in sources: + assert len(source) == 2 + assert DEFAULT_IMAGE_TOKEN in source[0]["value"] + source[0]["value"] = DEFAULT_IMAGE_TOKEN + conversation = source[0]["value"] + source[1]["value"] + conversation_lib.default_conversation.sep + conversations.append(conversation) + # tokenize conversations + input_ids = [tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations] + targets = copy.deepcopy(input_ids) + for target, source in zip(targets, sources): + tokenized_len = len(tokenizer_image_token(source[0]["value"], tokenizer)) + target[:tokenized_len] = IGNORE_INDEX + + return dict(input_ids=input_ids, labels=targets) + + +def preprocess(sources: Sequence[str], tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + """ + Given a list of sources, each is a conversation list. This transform: + 1. Add signal '### ' at the beginning each sentence, with end signal '\n'; + 2. Concatenate conversations together; + 3. Tokenize the concatenated conversation; + 4. Make a deepcopy as the target. Mask human words with IGNORE_INDEX. + """ + if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.PLAIN: + return preprocess_plain(sources, tokenizer) + if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.LLAMA_2: + return preprocess_llama_2(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version.startswith("v1"): + return preprocess_v1(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "mpt": + return preprocess_mpt(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "qwen": + return preprocess_qwen(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "gemma": + return preprocess_gemma(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "llama_v3": + return preprocess_llama3(sources, tokenizer, has_image=has_image) + # add end signal and concatenate together + conversations = [] + for source in sources: + header = f"{conversation_lib.default_conversation.system}\n\n" + conversation = _add_speaker_and_signal(header, source) + conversations.append(conversation) + + # tokenize conversations + def get_tokenize_len(prompts): + return [len(tokenizer_image_token(prompt, tokenizer)) for prompt in prompts] + + if has_image: + input_ids = [tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations] + else: + conversations_tokenized = _tokenize_fn(conversations, tokenizer) + input_ids = conversations_tokenized["input_ids"] + + targets = copy.deepcopy(input_ids) + for target, source in zip(targets, sources): + if has_image: + tokenized_lens = get_tokenize_len([header] + [s["value"] for s in source]) + else: + tokenized_lens = _tokenize_fn([header] + [s["value"] for s in source], tokenizer)["input_ids_lens"] + speakers = [sentence["from"] for sentence in source] + _mask_targets(target, tokenized_lens, speakers) + + return dict(input_ids=input_ids, labels=targets) + + +class LazySupervisedDataset(Dataset): + def __init__(self, data_path: str, tokenizer: transformers.PreTrainedTokenizer, data_args: DataArguments): + super(LazySupervisedDataset, self).__init__() + self.tokenizer = tokenizer + self.list_data_dict = [] + + # Handle multiple JSON files specified in the data_path + if "{" in data_path and "}" in data_path: + base_path, file_pattern = re.match(r"^(.*)\{(.*)\}\.json$", data_path).groups() + file_names = file_pattern.split(",") + rank0_print(f"Loading {file_names} from {base_path}") + data_args.dataset_paths = [] + for file_name in file_names: + data_args.dataset_paths.append(f"{base_path}{file_name}.json") + full_path = f"{base_path}{file_name}.json" + rank0_print(f"Loading {full_path}") + with open(full_path, "r") as file: + cur_data_dict = json.load(file) + rank0_print(f"Loaded {len(cur_data_dict)} samples from {full_path}") + self.list_data_dict.extend(cur_data_dict) + elif data_path.endswith(".yaml"): + with open(data_path, "r") as file: + yaml_data = yaml.safe_load(file) + datasets = yaml_data.get("datasets") + # file should be in the format of: + # datasets: + # - json_path: xxxx1.json + # sampling_strategy: first:1000 + # - json_path: xxxx2.json + # sampling_strategy: end:3000 + # - json_path: xxxx3.json + # sampling_strategy: random:999 + data_args.dataset_paths = [dataset.get("json_path") for dataset in datasets] + for dataset in datasets: + json_path = dataset.get("json_path") + sampling_strategy = dataset.get("sampling_strategy", "all") + sampling_number = None + + rank0_print(f"Loading {json_path} with {sampling_strategy} sampling strategy") + + if json_path.endswith(".jsonl"): + cur_data_dict = [] + with open(json_path, "r") as json_file: + for line in json_file: + cur_data_dict.append(json.loads(line.strip())) + elif json_path.endswith(".json"): + with open(json_path, "r") as json_file: + cur_data_dict = json.load(json_file) + else: + raise ValueError(f"Unsupported file type: {json_path}") + + if ":" in sampling_strategy: + sampling_strategy, sampling_number = sampling_strategy.split(":") + if "%" in sampling_number: + sampling_number = math.ceil(int(sampling_number.split("%")[0]) * len(cur_data_dict) / 100) + else: + sampling_number = int(sampling_number) + + # Apply the sampling strategy + if sampling_strategy == "first" and sampling_number is not None: + cur_data_dict = cur_data_dict[:sampling_number] + elif sampling_strategy == "end" and sampling_number is not None: + cur_data_dict = cur_data_dict[-sampling_number:] + elif sampling_strategy == "random" and sampling_number is not None: + random.shuffle(cur_data_dict) + cur_data_dict = cur_data_dict[:sampling_number] + + rank0_print(f"Loaded {len(cur_data_dict)} samples from {json_path}") + self.list_data_dict.extend(cur_data_dict) + else: + data_args.dataset_paths = [data_path] + rank0_print(f"Loading {data_path}") + with open(data_path, "r") as file: + cur_data_dict = json.load(file) + rank0_print(f"Loaded {len(cur_data_dict)} samples from {data_path}") + self.list_data_dict.extend(cur_data_dict) + + rank0_print(f"Loaded {len(self.list_data_dict)} samples from {data_path}") + rank0_print("Formatting inputs...Skip in lazy mode") + self.tokenizer = tokenizer + self.data_args = data_args + + def __len__(self): + return len(self.list_data_dict) + + @property + def lengths(self): + length_list = [] + for sample in self.list_data_dict: + img_tokens = 128 if "image" in sample else 0 + length_list.append(sum(len(conv["value"].split()) for conv in sample["conversations"]) + img_tokens) + return length_list + + @property + def modality_lengths(self): + length_list = [] + for sample in self.list_data_dict: + cur_len = sum(len(conv["value"].split()) for conv in sample["conversations"]) + assert cur_len > 0, f"Conversation length is 0 for {sample}" + if "image" in sample or "video" in sample or self.data_args.early_mix_text: + length_list.append(cur_len) + else: + length_list.append(-cur_len) + return length_list + + def process_image(self, image_file, overwrite_image_aspect_ratio=None): + image_folder = self.data_args.image_folder + processor = self.data_args.image_processor + # print(f"\n\nInspecting the image path, folder = {image_folder}, image={image_file}\n\n") + try: + image = Image.open(os.path.join(image_folder, image_file)).convert("RGB") + except Exception as exn: + print(f"Failed to open image {image_file}. Exception:", exn) + raise exn + + image_size = image.size + image_aspect_ratio = self.data_args.image_aspect_ratio + if overwrite_image_aspect_ratio is not None: + image_aspect_ratio = overwrite_image_aspect_ratio + if image_aspect_ratio == "highres": + image = process_highres_image(image, self.data_args.image_processor, self.data_args.image_grid_pinpoints) + elif image_aspect_ratio == "anyres" or "anyres_max" in image_aspect_ratio: + image = process_anyres_image(image, self.data_args.image_processor, self.data_args.image_grid_pinpoints) + elif image_aspect_ratio == "crop_split": + image = process_highres_image_crop_split(image, self.data_args) + elif image_aspect_ratio == "pad": + + def expand2square(pil_img, background_color): + width, height = pil_img.size + if width == height: + return pil_img + elif width > height: + result = Image.new(pil_img.mode, (width, width), background_color) + result.paste(pil_img, (0, (width - height) // 2)) + return result + else: + result = Image.new(pil_img.mode, (height, height), background_color) + result.paste(pil_img, ((height - width) // 2, 0)) + return result + + image = expand2square(image, tuple(int(x * 255) for x in processor.image_mean)) + image = processor.preprocess(image, return_tensors="pt")["pixel_values"][0] + else: + image = processor.preprocess(image, return_tensors="pt")["pixel_values"][0] + return image, image_size, "image" + + def __getitem__(self, i) -> Dict[str, torch.Tensor]: + # TODO: define number of retries somewhere else + num_base_retries = 3 + num_final_retries = 300 + + # try the current sample first + for attempt_idx in range(num_base_retries): + try: + sample = self._get_item(i) + return sample + except Exception as e: + # sleep 1s in case it is a cloud disk issue + print(f"[Try #{attempt_idx}] Failed to fetch sample {i}. Exception:", e) + time.sleep(1) + + # try other samples, in case it is file corruption issue + for attempt_idx in range(num_base_retries): + try: + next_index = min(i + 1, len(self.list_data_dict) - 1) + # sample_idx = random.choice(range(len(self))) + sample = self._get_item(next_index) + return sample + except Exception as e: + # no need to sleep + print(f"[Try other #{attempt_idx}] Failed to fetch sample {next_index}. Exception:", e) + pass + + try: + sample = self._get_item(i) + return sample + except Exception as e: + raise e + + def _get_item(self, i) -> Dict[str, torch.Tensor]: + sources = self.list_data_dict[i] + if isinstance(i, int): + sources = [sources] + assert len(sources) == 1, "Don't know why it is wrapped to a list" # FIXME + + if "image" in sources[0]: + image_file = self.list_data_dict[i]["image"] + if type(image_file) is list: + image = [self.process_image(f) for f in image_file] + # Handling multi images + # overwrite to process with simple pad + if len(image_file) > 1: + image = [self.process_image(f, "pad") for f in image_file] + image = [[im[0], im[1], "image"] for im in image] + else: + image = [self.process_image(image_file)] + sources = preprocess_multimodal(copy.deepcopy([e["conversations"] for e in sources]), self.data_args) + + elif "video" in sources[0]: + video_file = self.list_data_dict[i]["video"] + video_folder = self.data_args.video_folder + video_file = os.path.join(video_folder, video_file) + suffix = video_file.split(".")[-1] + if not os.path.exists(video_file): + print("File {} not exist!".format(video_file)) + + try: + if "shareVideoGPTV" in video_file: + frame_files = [os.path.join(video_file, f) for f in os.listdir(video_file) if os.path.isfile(os.path.join(video_file, f))] + frame_files.sort() # Ensure the frames are sorted if they are named sequentially + + # TODO: Hard CODE: Determine the indices for uniformly sampling 10 frames + if self.data_args.force_sample: + num_frames_to_sample = self.data_args.frames_upbound + else: + num_frames_to_sample = 10 + + avg_fps = 2 + + total_frames = len(frame_files) + sampled_indices = np.linspace(0, total_frames - 1, num_frames_to_sample, dtype=int) + + + frame_time = [i/2 for i in sampled_indices] + frame_time = ",".join([f"{i:.2f}s" for i in frame_time]) + + video_time = total_frames / avg_fps + + # Read and store the sampled frames + video = [] + for idx in sampled_indices: + frame_path = frame_files[idx] + try: + with Image.open(frame_path) as img: + frame = img.convert("RGB") + video.append(frame) + except IOError: + print(f"Failed to read frame at path: {frame_path}") + else: + video, video_time, frame_time, num_frames_to_sample = process_video_with_decord(video_file, self.data_args) + + processor = self.data_args.image_processor + image = processor.preprocess(video, return_tensors="pt")["pixel_values"] + if self.data_args.add_time_instruction: + time_instruciton = f"The video lasts for {video_time:.2f} seconds, and {num_frames_to_sample} frames are uniformly sampled from it. These frames are located at {frame_time}.Please answer the following questions related to this video." + sources[0]["conversations"][0]["value"] = f'{DEFAULT_IMAGE_TOKEN}\n{time_instruciton}\n{sources[0]["conversations"][0]["value"].replace(DEFAULT_IMAGE_TOKEN, "")}' + image = [(image, video[0].size, "video")] + sources = preprocess_multimodal(copy.deepcopy([e["conversations"] for e in sources]), self.data_args) + # print(sources) + except Exception as e: + print(f"Error: {e}") + print(f"Failed to read video file: {video_file}") + return self._get_item(i + 1) + else: + sources = copy.deepcopy([e["conversations"] for e in sources]) + + has_image = ("image" in self.list_data_dict[i]) or ("video" in self.list_data_dict[i]) + data_dict = preprocess(sources, self.tokenizer, has_image=has_image) + + if "prompt" in data_dict: + prompt = data_dict["prompt"] + else: + prompt = None + + if isinstance(i, int): + data_dict = dict(input_ids=data_dict["input_ids"][0], labels=data_dict["labels"][0]) + + # image exist in the data + if "image" in self.list_data_dict[i]: + data_dict["image"] = image + elif "video" in self.list_data_dict[i]: + data_dict["image"] = image + elif self.data_args.is_multimodal: + # image does not exist in the data, but the model is multimodal + crop_size = self.data_args.image_processor.crop_size + data_dict["image"] = [ + (torch.zeros(1, 3, crop_size["height"], crop_size["width"]), (crop_size["width"], crop_size["height"]), "text"), + ] + # prompt exist in the data + if prompt is not None: + data_dict["prompt"] = prompt + + data_dict["id"] = self.list_data_dict[i].get("id", i) + + return data_dict + + +@dataclass +class DataCollatorForSupervisedDataset(object): + """Collate examples for supervised fine-tuning.""" + + tokenizer: transformers.PreTrainedTokenizer + + def pad_sequence(self, input_ids, batch_first, padding_value): + if self.tokenizer.padding_side == "left": + input_ids = [torch.flip(_input_ids, [0]) for _input_ids in input_ids] + input_ids = torch.nn.utils.rnn.pad_sequence(input_ids, batch_first=batch_first, padding_value=padding_value) + if self.tokenizer.padding_side == "left": + input_ids = torch.flip(input_ids, [1]) + return input_ids + + def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]: + input_ids, labels = tuple([instance[key] for instance in instances] for key in ("input_ids", "labels")) + # input_ids, labels, ids = tuple([instance[key] for instance in instances] for key in ("input_ids", "labels", "id")) + input_ids = [_input_ids[: self.tokenizer.model_max_length] for _input_ids in input_ids] + labels = [_labels[: self.tokenizer.model_max_length] for _labels in labels] + if self.tokenizer.pad_token_id is None: + # self.tokenizer.pad_token_id = self.tokenizer.eos_token_id # FIXME: this could only be triggered for llama3 model. + self.tokenizer.pad_token_id = 0 # This gets the best result. Don't know why. + input_ids = self.pad_sequence(input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id) + labels = self.pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX) + batch = dict(input_ids=input_ids, labels=labels.long() if labels.dtype == torch.int32 else labels, attention_mask=input_ids.ne(self.tokenizer.pad_token_id)) + # batch = dict(input_ids=input_ids, labels=labels, attention_mask=input_ids.ne(self.tokenizer.pad_token_id), ids=ids) + + if "image" in instances[0]: + images = [instance["image"] for instance in instances] + + batch["image_sizes"] = [im[1] for im_list in images for im in im_list] + batch["modalities"] = [im[2] for im_list in images for im in im_list] + images = [im[0] for im_list in images for im in im_list] + + # if all(x is not None and x.shape == images[0].shape for x in images): + # Image: (N, P, C, H, W) + # Video: (N, F, C, H, W) + # batch["images"] = torch.stack(images) + # else: + batch["images"] = images + + if "prompt" in instances[0]: + batch["prompts"] = [instance["prompt"] for instance in instances] + + return batch + + +def make_supervised_data_module(tokenizer: transformers.PreTrainedTokenizer, data_args) -> Dict: + """Make dataset and collator for supervised fine-tuning.""" + train_dataset = LazySupervisedDataset(tokenizer=tokenizer, data_path=data_args.data_path, data_args=data_args) + data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer) + return dict(train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator) + + +def get_model(model_args, training_args, bnb_model_from_pretrained_args): + assert training_args.attn_implementation + if training_args.attn_implementation == "sdpa" and torch.__version__ < "2.1.2": + raise ValueError("The 'sdpa' attention implementation requires torch version 2.1.2 or higher.") + + customized_kwargs = dict() + customized_kwargs.update(bnb_model_from_pretrained_args) + cfg_pretrained = None + + overwrite_config = {} + if any( + [ + model_args.rope_scaling_factor is not None, + model_args.rope_scaling_type is not None, + model_args.mm_spatial_pool_stride is not None, + model_args.mm_spatial_pool_out_channels is not None, + model_args.mm_spatial_pool_mode is not None, + model_args.mm_resampler_type is not None, + ] + ): + cfg_pretrained = AutoConfig.from_pretrained(model_args.model_name_or_path) + + if model_args.use_pos_skipping is not None and model_args.pos_skipping_range is not None: + overwrite_config["use_pos_skipping"] = model_args.use_pos_skipping + overwrite_config["pos_skipping_range"] = model_args.pos_skipping_range + + if model_args.rope_scaling_factor is not None and model_args.rope_scaling_type is not None: + overwrite_config["rope_scaling"] = { + "factor": model_args.rope_scaling_factor, + "type": model_args.rope_scaling_type, + } + if training_args.model_max_length is None: + training_args.model_max_length = cfg_pretrained.max_position_embeddings * model_args.rope_scaling_factor + overwrite_config["max_sequence_length"] = training_args.model_max_length + assert training_args.model_max_length == int(cfg_pretrained.max_position_embeddings * model_args.rope_scaling_factor), print( + f"model_max_length: {training_args.model_max_length}, max_position_embeddings: {cfg_pretrained.max_position_embeddings}, rope_scaling_factor: {model_args.rope_scaling_factor}" + ) + # overwrite_config["max_sequence_length"] = model_args.max_sequence_length + # overwrite_config["tokenizer_model_max_length"] = model_args.tokenizer_model_max_length + + if model_args.mm_spatial_pool_stride is not None and model_args.mm_spatial_pool_out_channels is not None and model_args.mm_spatial_pool_mode is not None and model_args.mm_resampler_type is not None: + overwrite_config["mm_resampler_type"] = model_args.mm_resampler_type + overwrite_config["mm_spatial_pool_stride"] = model_args.mm_spatial_pool_stride + overwrite_config["mm_spatial_pool_out_channels"] = model_args.mm_spatial_pool_out_channels + overwrite_config["mm_spatial_pool_mode"] = model_args.mm_spatial_pool_mode + + if model_args.mm_spatial_pool_mode is not None: + overwrite_config["mm_spatial_pool_mode"] = model_args.mm_spatial_pool_mode + + if overwrite_config: + assert cfg_pretrained is not None, "cfg_pretrained is None" + + rank0_print(f"Overwriting config with {overwrite_config}") + for k, v in overwrite_config.items(): + setattr(cfg_pretrained, k, v) + + customized_kwargs["config"] = cfg_pretrained + + if model_args.model_class_name is not None: + actual_model_class_name = f"{model_args.model_class_name}ForCausalLM" + model_class = getattr(transformers, actual_model_class_name) + rank0_print(f"Using model class {model_class} from {model_args.model_class_name}") + model = model_class.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + elif model_args.vision_tower is not None: + if "mixtral" in model_args.model_name_or_path.lower(): + model = LlavaMixtralForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + from transformers.models.mixtral.modeling_mixtral import MixtralSparseMoeBlock + + deepspeed.utils.set_z3_leaf_modules(model, [MixtralSparseMoeBlock]) + elif "mistral" in model_args.model_name_or_path.lower() or "zephyr" in model_args.model_name_or_path.lower(): + model = LlavaMistralForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + elif ( + "wizardlm-2" in model_args.model_name_or_path.lower() + or "vicuna" in model_args.model_name_or_path.lower() + or "llama" in model_args.model_name_or_path.lower() + or "yi" in model_args.model_name_or_path.lower() + or "nous-hermes" in model_args.model_name_or_path.lower() + and "wizard-2" in model_args.model_name_or_path.lower() + ): + model = LlavaLlamaForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + elif "qwen" in model_args.model_name_or_path.lower(): + if "moe" in model_args.model_name_or_path.lower() or "A14B" in model_args.model_name_or_path: + model = LlavaQwenMoeForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + from transformers.models.qwen2_moe.modeling_qwen2_moe import Qwen2MoeSparseMoeBlock + + deepspeed.utils.set_z3_leaf_modules(model, [Qwen2MoeSparseMoeBlock]) + else: + model = LlavaQwenForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + elif "gemma" in model_args.model_name_or_path.lower(): + model = LlavaGemmaForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + else: + raise ValueError(f"Unknown model class {model_args}") + else: + model = transformers.LlamaForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + return model + + +def train(attn_implementation=None): + global local_rank + + parser = transformers.HfArgumentParser((ModelArguments, DataArguments, TrainingArguments)) + model_args, data_args, training_args = parser.parse_args_into_dataclasses() + + if training_args.verbose_logging: + rank0_print(f"Inspecting experiment hyperparameters:\n") + rank0_print(f"model_args = {vars(model_args)}\n\n") + rank0_print(f"data_args = {vars(data_args)}\n\n") + rank0_print(f"training_args = {vars(training_args)}\n\n") + # rank0_print(f"evaluation_args = {vars(evaluation_args)}\n\n") + + local_rank = training_args.local_rank + compute_dtype = torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32) + + bnb_model_from_pretrained_args = {} + if training_args.bits in [4, 8]: + from transformers import BitsAndBytesConfig + + bnb_model_from_pretrained_args.update( + dict( + device_map={"": training_args.device}, + load_in_4bit=training_args.bits == 4, + load_in_8bit=training_args.bits == 8, + quantization_config=BitsAndBytesConfig( + load_in_4bit=training_args.bits == 4, + load_in_8bit=training_args.bits == 8, + llm_int8_threshold=6.0, + llm_int8_has_fp16_weight=False, + bnb_4bit_compute_dtype=compute_dtype, + bnb_4bit_use_double_quant=training_args.double_quant, + bnb_4bit_quant_type=training_args.quant_type, # {'fp4', 'nf4'} + ), + ) + ) + + model = get_model(model_args, training_args, bnb_model_from_pretrained_args) + model.config.use_cache = False + if model_args.rope_scaling_factor is not None and model_args.rope_scaling_type is not None: + model.config.rope_scaling = { + "factor": model_args.rope_scaling_factor, + "type": model_args.rope_scaling_type, + } + + if model_args.freeze_backbone: + model.model.requires_grad_(False) + + if training_args.bits in [4, 8]: + from peft import prepare_model_for_kbit_training + + model.config.torch_dtype = torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32) + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing) + + if training_args.gradient_checkpointing: + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + if training_args.lora_enable: + from peft import LoraConfig, get_peft_model + + lora_config = LoraConfig( + r=training_args.lora_r, + lora_alpha=training_args.lora_alpha, + target_modules=find_all_linear_names(model), + lora_dropout=training_args.lora_dropout, + bias=training_args.lora_bias, + task_type="CAUSAL_LM", + ) + if training_args.bits == 16: + if training_args.bf16: + model.to(torch.bfloat16) + if training_args.fp16: + model.to(torch.float16) + rank0_print("Adding LoRA adapters...") + model = get_peft_model(model, lora_config) + + if "mistral" in model_args.model_name_or_path.lower() or "mixtral" in model_args.model_name_or_path.lower() or "zephyr" in model_args.model_name_or_path.lower(): + tokenizer = transformers.AutoTokenizer.from_pretrained(model_args.model_name_or_path, cache_dir=training_args.cache_dir, model_max_length=training_args.model_max_length, padding_side="left") + elif "qwen" in model_args.model_name_or_path.lower(): + tokenizer = transformers.AutoTokenizer.from_pretrained(model_args.model_name_or_path, cache_dir=training_args.cache_dir, model_max_length=training_args.model_max_length, padding_side="right") + elif ( + "wizardlm-2" in model_args.model_name_or_path.lower() + or "vicuna" in model_args.model_name_or_path.lower() + or "llama" in model_args.model_name_or_path.lower() + or "yi" in model_args.model_name_or_path.lower() + or "nous-hermes" in model_args.model_name_or_path.lower() + and "wizard-2" in model_args.model_name_or_path.lower() + ): + tokenizer = transformers.AutoTokenizer.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + model_max_length=training_args.model_max_length, + padding_side="right", + use_fast=False, + ) + + rank0_print(f"Prompt version: {model_args.version}") + if model_args.version == "v0": + if tokenizer.pad_token is None: + smart_tokenizer_and_embedding_resize( + special_tokens_dict=dict(pad_token="[PAD]"), + tokenizer=tokenizer, + model=model, + ) + elif model_args.version == "v0.5": + tokenizer.pad_token = tokenizer.unk_token + else: + if tokenizer.unk_token is not None: + tokenizer.pad_token = tokenizer.unk_token + if model_args.version in conversation_lib.conv_templates: + conversation_lib.default_conversation = conversation_lib.conv_templates[model_args.version] + else: + conversation_lib.default_conversation = conversation_lib.conv_templates["vicuna_v1"] + + if model_args.vision_tower is not None: + model.get_model().initialize_vision_modules(model_args=model_args, fsdp=training_args.fsdp) + + vision_tower = model.get_vision_tower() + vision_tower.to(dtype=torch.bfloat16 if training_args.bf16 else torch.float16, device=training_args.device) + + data_args.image_processor = vision_tower.image_processor + data_args.is_multimodal = True + + model.config.image_aspect_ratio = data_args.image_aspect_ratio + if data_args.image_grid_pinpoints is not None: + if isinstance(data_args.image_grid_pinpoints, str) and "x" in data_args.image_grid_pinpoints: + try: + patch_size = data_args.image_processor.size[0] + except Exception as e: + patch_size = data_args.image_processor.size["shortest_edge"] + + assert patch_size in [224, 336, 384, 448, 512], "patch_size should be in [224, 336, 384, 448, 512]" + # Use regex to extract the range from the input string + matches = re.findall(r"\((\d+)x(\d+)\)", data_args.image_grid_pinpoints) + range_start = tuple(map(int, matches[0])) + range_end = tuple(map(int, matches[-1])) + # Generate a matrix of tuples from (range_start[0], range_start[1]) to (range_end[0], range_end[1]) + grid_pinpoints = [(i, j) for i in range(range_start[0], range_end[0] + 1) for j in range(range_start[1], range_end[1] + 1)] + # Multiply all elements by patch_size + data_args.image_grid_pinpoints = [[dim * patch_size for dim in pair] for pair in grid_pinpoints] + elif isinstance(data_args.image_grid_pinpoints, str): + data_args.image_grid_pinpoints = ast.literal_eval(data_args.image_grid_pinpoints) + + model.config.image_grid_pinpoints = data_args.image_grid_pinpoints + model.config.image_crop_resolution = data_args.image_crop_resolution + model.config.image_split_resolution = data_args.image_split_resolution + model.config.tokenizer_padding_side = tokenizer.padding_side + model.config.tokenizer_model_max_length = tokenizer.model_max_length + model.config.mm_newline_position = model_args.mm_newline_position + model.config.add_faster_video = model_args.add_faster_video + model.config.faster_token_stride = model_args.faster_token_stride + model.config.add_time_instruction = data_args.add_time_instruction + model.config.force_sample = data_args.force_sample + model.config.mm_spatial_pool_stride = model_args.mm_spatial_pool_stride + + ### Deciding train which part of the model + if model_args.mm_tunable_parts is None: # traditional way of deciding which part to train + model.config.tune_mm_mlp_adapter = training_args.tune_mm_mlp_adapter = model_args.tune_mm_mlp_adapter + model.config.tune_mm_vision_resampler = training_args.tune_mm_vision_resampler = model_args.tune_mm_vision_resampler + if model_args.tune_mm_mlp_adapter or model_args.tune_mm_vision_resampler: + model.requires_grad_(False) + if model_args.tune_mm_mlp_adapter: + for p in model.get_model().mm_projector.parameters(): + p.requires_grad = True + if model_args.tune_mm_vision_resampler: + for p in model.get_model().vision_resampler.parameters(): + p.requires_grad = True + + model.config.freeze_mm_mlp_adapter = training_args.freeze_mm_mlp_adapter + if training_args.freeze_mm_mlp_adapter: + for p in model.get_model().mm_projector.parameters(): + p.requires_grad = False + + model.config.freeze_mm_vision_resampler = training_args.freeze_mm_vision_resampler + if training_args.freeze_mm_vision_resampler: + for p in model.get_model().vision_resampler.parameters(): + p.requires_grad = False + + model.config.unfreeze_mm_vision_tower = model_args.unfreeze_mm_vision_tower + if model_args.unfreeze_mm_vision_tower: + vision_tower.requires_grad_(True) + else: + vision_tower.requires_grad_(False) + + else: + rank0_print(f"Using mm_tunable_parts: {model_args.mm_tunable_parts}") + model.config.mm_tunable_parts = training_args.mm_tunable_parts = model_args.mm_tunable_parts + # Set the entire model to not require gradients by default + model.requires_grad_(False) + vision_tower.requires_grad_(False) + model.get_model().mm_projector.requires_grad_(False) + model.get_model().vision_resampler.requires_grad_(False) + # Parse the mm_tunable_parts to decide which parts to unfreeze + tunable_parts = model_args.mm_tunable_parts.split(",") + if "mm_mlp_adapter" in tunable_parts: + for p in model.get_model().mm_projector.parameters(): + p.requires_grad = True + if "mm_vision_resampler" in tunable_parts: + for p in model.get_model().vision_resampler.parameters(): + p.requires_grad = True + if "mm_vision_tower" in tunable_parts: + for name, param in model.named_parameters(): + if "vision_tower" in name: + param.requires_grad_(True) + if "mm_language_model" in tunable_parts: + for name, param in model.named_parameters(): + if "vision_tower" not in name and "mm_projector" not in name and "vision_resampler" not in name: + param.requires_grad_(True) + + total_params = sum(p.ds_numel if hasattr(p, "ds_numel") else p.numel() for p in model.parameters()) + trainable_params = sum(p.ds_numel if hasattr(p, "ds_numel") else p.numel() for p in model.parameters() if p.requires_grad) + rank0_print(f"Total parameters: ~{total_params/1e6:.2f} MB)") + rank0_print(f"Trainable parameters: ~{trainable_params/1e6:.2f} MB)") + if training_args.bits in [4, 8]: + model.get_model().mm_projector.to(dtype=compute_dtype, device=training_args.device) + + model.config.mm_use_im_start_end = data_args.mm_use_im_start_end = model_args.mm_use_im_start_end + model.config.mm_projector_lr = training_args.mm_projector_lr + model.config.mm_vision_tower_lr = training_args.mm_vision_tower_lr + training_args.use_im_start_end = model_args.mm_use_im_start_end + model.config.mm_use_im_patch_token = model_args.mm_use_im_patch_token + model.initialize_vision_tokenizer(model_args, tokenizer=tokenizer) + + if training_args.bits in [4, 8]: + from peft.tuners.lora import LoraLayer + + for name, module in model.named_modules(): + if isinstance(module, LoraLayer): + if training_args.bf16: + module = module.to(torch.bfloat16) + if "norm" in name: + module = module.to(torch.float32) + if "lm_head" in name or "embed_tokens" in name: + if hasattr(module, "weight"): + if training_args.bf16 and module.weight.dtype == torch.float32: + module = module.to(torch.bfloat16) + + data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args) + trainer = LLaVATrainer(model=model, tokenizer=tokenizer, args=training_args, **data_module) + + if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")): + trainer.train(resume_from_checkpoint=True) + else: + trainer.train() + trainer.save_state() + + model.config.use_cache = True + + if training_args.lora_enable: + state_dict = get_peft_state_maybe_zero_3(model.named_parameters(), training_args.lora_bias) + non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(model.named_parameters()) + if training_args.local_rank == 0 or training_args.local_rank == -1: + if hasattr(model, "config"): + model.config.save_pretrained(training_args.output_dir) + if hasattr(model, "generation_config"): + model.generation_config.save_pretrained(training_args.output_dir) + model.save_pretrained(training_args.output_dir, state_dict=state_dict) + torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, "non_lora_trainables.bin")) + else: + safe_save_model_for_hf_trainer(trainer=trainer, output_dir=training_args.output_dir) + + rank0_print(f"Model saved to {training_args.output_dir}") + + +if __name__ == "__main__": + train() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train_dpo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train_dpo.py new file mode 100644 index 0000000000000000000000000000000000000000..037eec42fb75a5f04f4d46502906731f6c9d5011 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train_dpo.py @@ -0,0 +1,1782 @@ +# Adopted from https://github.com/lm-sys/FastChat. Below is the original copyright: +# Adopted from tatsu-lab@stanford_alpaca. Below is the original copyright: +# Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import copy +import deepspeed +from dataclasses import dataclass, field +import json +import logging +import pathlib +from typing import Dict, Optional, Sequence, List +import ast + +import yaml +import time +import random +import yaml +import math +import re +import torch + +import transformers +import tokenizers + +from llava.constants import IGNORE_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN, IMAGE_TOKEN_INDEX +from torch.utils.data import Dataset +from llava.train.llava_trainer import LLaVADPOTrainer +from data_processing.utils import load_jsonl, load_json +from llava import conversation as conversation_lib +from llava.model import * +from llava.model.language_model.llava_qwen import LlavaQwenConfig +from llava.model.language_model.llava_llama import LlavaConfig +from llava.model.language_model.llava_mistral import LlavaMistralConfig +from llava.mm_utils import process_highres_image, process_anyres_image, process_highres_image_crop_split, tokenizer_image_token +from llava.utils import rank0_print +from transformers import AutoConfig +import pickle + +from trl.trainer.utils import DPODataCollatorWithPadding +from PIL import Image, ImageFile +from decord import VideoReader, cpu + +ImageFile.LOAD_TRUNCATED_IMAGES = True +from packaging import version +from typing import Any + +local_rank = None +import numpy as np + +IS_TOKENIZER_GREATER_THAN_0_14 = version.parse(tokenizers.__version__) >= version.parse("0.14") + + +@dataclass +class ModelArguments: + model_name_or_path: Optional[str] = field(default="facebook/opt-125m") + model_class_name: Optional[str] = field(default=None, metadata={"help": "Used to init model class, format is XXXXForCausalLM. e.g. currently XXXX is chosen from LlavaLlama, LlavaMixtral, LlavaMistral, Llama"}) + + mm_tunable_parts: Optional[str] = field( + default=None, metadata={"help": 'Could be "mm_mlp_adapter", "mm_vision_resampler", "mm_vision_tower,mm_mlp_adapter,mm_language_model", "mm_vision_tower,mm_mlp_adapter,mm_language_model", "mm_mlp_adapter,mm_language_model"'} + ) + # deciding which part of the multimodal model to tune, will overwrite other previous settings + + version: Optional[str] = field(default="v0") + freeze_backbone: bool = field(default=False) + tune_mm_mlp_adapter: bool = field(default=False) + tune_mm_vision_resampler: bool = field(default=False) + vision_tower: Optional[str] = field(default=None) + vision_tower_pretrained: Optional[str] = field(default=None) # default to the last layer + + unfreeze_mm_vision_tower: bool = field(default=False) + unfreeze_language_model: bool = field(default=False) + mm_vision_select_layer: Optional[int] = field(default=-1) # default to the last layer + pretrain_mm_mlp_adapter: Optional[str] = field(default=None) + mm_projector_type: Optional[str] = field(default="linear") + mm_use_im_start_end: bool = field(default=False) + mm_use_im_patch_token: bool = field(default=True) + mm_patch_merge_type: Optional[str] = field(default="flat") + mm_vision_select_feature: Optional[str] = field(default="patch") + mm_resampler_type: Optional[str] = field(default=None) + mm_mask_drop_mode: str = field(default="fixed") + mm_mask_drop_skip_percentage: float = field(default=0.0) + mm_mask_drop_ratio: float = field(default=0.25) + mm_mask_drop_ratio_upper: Optional[float] = field(default=None) + mm_mask_drop_ratio_lower: Optional[float] = field(default=None) + mm_spatial_pool_stride: Optional[int] = field(default=None) + mm_spatial_pool_mode: str = field(default="average") + mm_spatial_pool_out_channels: Optional[int] = field(default=None) + mm_perceiver_depth: Optional[int] = field(default=3) + mm_perceiver_latents: Optional[int] = field(default=32) + mm_perceiver_ff_mult: Optional[float] = field(default=4) + mm_perceiver_pretrained: Optional[str] = field(default=None) + mm_qformer_depth: Optional[int] = field(default=3) + mm_qformer_latents: Optional[int] = field(default=32) + mm_qformer_pretrained: Optional[str] = field(default=None) + + rope_scaling_factor: Optional[float] = field(default=None) + rope_scaling_type: Optional[str] = field(default=None) + + s2: Optional[bool] = field(default=False) + s2_scales: Optional[str] = field(default="336,672,1008") + + +@dataclass +class DataArguments: + data_path: str = field(default=None, metadata={"help": "Path to the training data, in llava's instruction.json format. Supporting multiple json files via /path/to/{a,b,c}.json"}) + lazy_preprocess: bool = False + is_multimodal: bool = False + image_folder: Optional[str] = field(default=None) + video_folder: Optional[str] = field(default=None) + video_fps: Optional[int] = field(default=1) + image_aspect_ratio: str = "square" + image_grid_pinpoints: Optional[str] = field(default=None) + image_crop_resolution: int = 384 + image_split_resolution: int = 384 + input_prompt: Optional[str] = field(default=None) + refine_prompt: Optional[bool] = field(default=False) + frames_upbound: Optional[int] = field(default=0) + num_sample: Optional[int] = field(default=None) + + +@dataclass +class TrainingArguments(transformers.TrainingArguments): + cache_dir: Optional[str] = field(default=None) + optim: str = field(default="adamw_torch") + remove_unused_columns: bool = field(default=False) + freeze_mm_mlp_adapter: bool = field(default=False) + freeze_mm_vision_resampler: bool = field(default=False) + mpt_attn_impl: Optional[str] = field(default="triton") + model_max_length: int = field( + default=4096, + metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."}, + ) + double_quant: bool = field(default=True, metadata={"help": "Compress the quantization statistics through double quantization."}) + quant_type: str = field(default="nf4", metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}) + bits: int = field(default=16, metadata={"help": "How many bits to use."}) + lora_enable: bool = False + lora_r: int = 64 + lora_alpha: int = 16 + lora_dropout: float = 0.05 + lora_weight_path: str = "" + lora_bias: str = "none" + mm_projector_lr: Optional[float] = None + mm_vision_tower_lr: Optional[float] = None + group_by_varlen: bool = field(default=False) + group_by_modality_length: bool = field(default=False) + group_by_modality_length_auto: bool = field(default=False) + auto_find_batch_size: bool = field(default=False) + gradient_checkpointing: bool = field(default=True) + verbose_logging: bool = field(default=False) + attn_implementation: str = field(default="flash_attention_2", metadata={"help": "Use transformers attention implementation."}) + dpo_alpha: float = field(default=1.0) + beta: float = field(default=0.1) + gamma: float = field(default=1.0) + generate_during_eval: bool = field(default=False) + precompute_ref_log_probs: bool = field(default=False) + + +def maybe_zero_3(param, ignore_status=False, name=None): + from deepspeed import zero + from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus + + if hasattr(param, "ds_id"): + if param.ds_status == ZeroParamStatus.NOT_AVAILABLE: + if not ignore_status: + logging.warning(f"{name}: param.ds_status != ZeroParamStatus.NOT_AVAILABLE: {param.ds_status}") + with zero.GatheredParameters([param]): + param = param.data.detach().cpu().clone() + else: + param = param.detach().cpu().clone() + return param + + +# Borrowed from peft.utils.get_peft_model_state_dict +def get_peft_state_maybe_zero_3(named_params, bias): + if bias == "none": + to_return = {k: t for k, t in named_params if "lora_" in k} + elif bias == "all": + to_return = {k: t for k, t in named_params if "lora_" in k or "bias" in k} + elif bias == "lora_only": + to_return = {} + maybe_lora_bias = {} + lora_bias_names = set() + for k, t in named_params: + if "lora_" in k: + to_return[k] = t + bias_name = k.split("lora_")[0] + "bias" + lora_bias_names.add(bias_name) + elif "bias" in k: + maybe_lora_bias[k] = t + for k, t in maybe_lora_bias: + if bias_name in lora_bias_names: + to_return[bias_name] = t + else: + raise NotImplementedError + to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()} + return to_return + + +def get_peft_state_non_lora_maybe_zero_3(named_params, require_grad_only=True): + to_return = {k: t for k, t in named_params if "lora_" not in k} + if require_grad_only: + to_return = {k: t for k, t in to_return.items() if t.requires_grad} + to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()} + return to_return + + +def get_mm_adapter_state_maybe_zero_3(named_params, keys_to_match): + to_return = {k: t for k, t in named_params if any(key_match in k for key_match in keys_to_match)} + to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()} + return to_return + + +def find_all_linear_names(model): + cls = torch.nn.Linear + lora_module_names = set() + multimodal_keywords = ["mm_projector", "vision_tower", "vision_resampler"] + for name, module in model.named_modules(): + if any(mm_keyword in name for mm_keyword in multimodal_keywords): + continue + if isinstance(module, cls): + names = name.split(".") + lora_module_names.add(names[0] if len(names) == 1 else names[-1]) + + if "lm_head" in lora_module_names: # needed for 16-bit + lora_module_names.remove("lm_head") + return list(lora_module_names) + + +def safe_save_model_for_hf_trainer(trainer: transformers.Trainer, output_dir: str): + """Collects the state dict and dump to disk.""" + if hasattr(trainer.args, "tune_mm_mlp_adapter") and trainer.args.tune_mm_mlp_adapter: + check_only_save_mm_adapter_tunnable = True + # only has mm_mlp_adapter and mm_vision_resampler in the tuneable parts + elif hasattr(trainer.args, "mm_tunable_parts") and (len(trainer.args.mm_tunable_parts.split(",")) == 1 and ("mm_mlp_adapter" in trainer.args.mm_tunable_parts or "mm_vision_resampler" in trainer.args.mm_tunable_parts)): + check_only_save_mm_adapter_tunnable = True + else: + check_only_save_mm_adapter_tunnable = False + + trainer.accelerator.wait_for_everyone() + torch.cuda.synchronize() + rank0_print(f"Only save projectors: {check_only_save_mm_adapter_tunnable}") + if check_only_save_mm_adapter_tunnable: + # Only save Adapter + keys_to_match = ["mm_projector", "vision_resampler"] + if getattr(trainer.args, "use_im_start_end", False): + keys_to_match.extend(["embed_tokens", "embed_in"]) + + weight_to_save = get_mm_adapter_state_maybe_zero_3(trainer.model.named_parameters(), keys_to_match) + trainer.model.config.save_pretrained(output_dir) + + current_folder = output_dir.split("/")[-1] + parent_folder = os.path.dirname(output_dir) + if trainer.args.local_rank == 0 or trainer.args.local_rank == -1: + if current_folder.startswith("checkpoint-"): + mm_projector_folder = os.path.join(parent_folder, "mm_projector") + os.makedirs(mm_projector_folder, exist_ok=True) + torch.save(weight_to_save, os.path.join(mm_projector_folder, f"{current_folder}.bin")) + else: + torch.save(weight_to_save, os.path.join(output_dir, f"mm_projector.bin")) + return + + if trainer.deepspeed: + trainer.save_model(output_dir) + return + + state_dict = trainer.model.state_dict() + if trainer.args.should_save: + cpu_state_dict = {key: value.cpu() for key, value in state_dict.items()} + del state_dict + trainer._save(output_dir, state_dict=cpu_state_dict) # noqa + + +def smart_tokenizer_and_embedding_resize( + special_tokens_dict: Dict, + tokenizer: transformers.PreTrainedTokenizer, + model: transformers.PreTrainedModel, +): + """Resize tokenizer and embedding. + + Note: This is the unoptimized version that may make your embedding size not be divisible by 64. + """ + num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict) + model.resize_token_embeddings(len(tokenizer)) + + if num_new_tokens > 0: + input_embeddings = model.get_input_embeddings().weight.data + output_embeddings = model.get_output_embeddings().weight.data + + input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True) + output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True) + + input_embeddings[-num_new_tokens:] = input_embeddings_avg + output_embeddings[-num_new_tokens:] = output_embeddings_avg + + +def _tokenize_fn(strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer) -> Dict: + """Tokenize a list of strings.""" + tokenized_list = [ + tokenizer( + text, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ) + for text in strings + ] + input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list] + input_ids_lens = labels_lens = [tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item() for tokenized in tokenized_list] + return dict( + input_ids=input_ids, + labels=labels, + input_ids_lens=input_ids_lens, + labels_lens=labels_lens, + ) + + +def _mask_targets(target, tokenized_lens, speakers): + # cur_idx = 0 + cur_idx = tokenized_lens[0] + tokenized_lens = tokenized_lens[1:] + target[:cur_idx] = IGNORE_INDEX + for tokenized_len, speaker in zip(tokenized_lens, speakers): + if speaker == "human": + target[cur_idx + 2 : cur_idx + tokenized_len] = IGNORE_INDEX + cur_idx += tokenized_len + + +def _add_speaker_and_signal(header, source, get_conversation=True): + """Add speaker and start/end signal on each round.""" + BEGIN_SIGNAL = "### " + END_SIGNAL = "\n" + conversation = header + for sentence in source: + from_str = sentence["from"] + if from_str.lower() == "human": + from_str = conversation_lib.default_conversation.roles[0] + elif from_str.lower() == "gpt": + from_str = conversation_lib.default_conversation.roles[1] + else: + from_str = "unknown" + sentence["value"] = BEGIN_SIGNAL + from_str + ": " + sentence["value"] + END_SIGNAL + if get_conversation: + conversation += sentence["value"] + conversation += BEGIN_SIGNAL + return conversation + + +def preprocess_multimodal(sources: Sequence[str], data_args: DataArguments) -> Dict: + is_multimodal = data_args.is_multimodal + if not is_multimodal: + return sources + + for source in sources: + for sentence in source: + if DEFAULT_IMAGE_TOKEN in sentence["value"] and not sentence["value"].startswith(DEFAULT_IMAGE_TOKEN): + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, "").strip() + sentence["value"] = DEFAULT_IMAGE_TOKEN + "\n" + sentence["value"] + sentence["value"] = sentence["value"].strip() + if "mmtag" in conversation_lib.default_conversation.version: + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, "" + DEFAULT_IMAGE_TOKEN + "") + replace_token = DEFAULT_IMAGE_TOKEN + if data_args.mm_use_im_start_end: + replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, replace_token) + + return sources + + +def preprocess_multimodal_movie(sources: Sequence[str], data_args: DataArguments, video_inputs: str) -> Dict: + is_multimodal = data_args.is_multimodal + if not is_multimodal: + return sources + + for source in sources: + for sentence in source: + if DEFAULT_IMAGE_TOKEN in sentence["value"]: + prompt = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, "").strip() + replace_token = video_inputs + if data_args.mm_use_im_start_end: + replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN + sentence["value"] = sentence["value"].replace(DEFAULT_IMAGE_TOKEN, replace_token) + + return sources, prompt + + +def preprocess_llama_2(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv = conversation_lib.default_conversation.copy() + roles = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + + if has_image: + input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets = input_ids.clone() + + assert conv.sep_style == conversation_lib.SeparatorStyle.LLAMA_2 + + # Mask targets + sep = "[/INST] " + for conversation, target in zip(conversations, targets): + total_len = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds = conversation.split(conv.sep2) + cur_len = 1 + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2 + else: + round_len = len(tokenizer(rou).input_ids) + instruction_len = len(tokenizer(parts[0]).input_ids) - 2 + + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + + cur_len += round_len + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + rank0_print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f" (ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def make_conv(prompt, answer): + return [ + { + "from": "human", + "value": prompt, + }, + { + "from": "gpt", + "value": answer, + }, + ] + + +def preprocess_gemma(sources: List[List[Dict[str, str]]], tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv: conversation_lib.Conversation = conversation_lib.default_conversation.copy() + roles: Dict[str, str] = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations: List[str] = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source: List[Dict[str, str]] = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role: str = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + if has_image: + input_ids: torch.Tensor = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids: torch.Tensor = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets: torch.Tensor = input_ids.clone() + assert conv.sep_style == conversation_lib.SeparatorStyle.GEMMA + + # Mask target + sep: str = conv.sep + conv.roles[1] + for conversation, target in zip(conversations, targets): + total_len: int = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds: List[str] = conversation.split(conv.sep) + re_rounds = [] + for conv_idx in range(0, len(rounds), 2): + re_rounds.append(conv.sep.join(rounds[conv_idx : conv_idx + 2])) + + cur_len = 1 # Ignore + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(re_rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep # Re-append sep because split on this + # Now "".join(parts)==rou + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) - 1 # Ignore + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 1 # Ignore + else: + round_len = len(tokenizer(rou).input_ids) - 1 # Ignore + instruction_len = len(tokenizer(parts[0]).input_ids) - 1 # Ignore + + round_len += 2 # sep: \n takes 2 tokens + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + cur_len += round_len + + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + rank0_print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f" (ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_qwen(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False, max_len=2048, system_message: str = "You are a helpful assistant.") -> Dict: + roles = {"human": "<|im_start|>user", "gpt": "<|im_start|>assistant"} + + im_start, im_end = tokenizer.additional_special_tokens_ids + nl_tokens = tokenizer("\n").input_ids + _system = tokenizer("system").input_ids + nl_tokens + _user = tokenizer("user").input_ids + nl_tokens + _assistant = tokenizer("assistant").input_ids + nl_tokens + + # Apply prompt templates + input_ids, targets = [], [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != roles["human"]: + source = source[1:] + + input_id, target = [], [] + system = [im_start] + _system + tokenizer(system_message).input_ids + [im_end] + nl_tokens + input_id += system + target += [im_start] + [IGNORE_INDEX] * (len(system) - 3) + [im_end] + nl_tokens + assert len(input_id) == len(target) + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + if has_image and "" in sentence["value"]: + assert sentence["value"].startswith(""), print(sentence["value"]) + + _input_id = tokenizer(role).input_ids + nl_tokens + [IMAGE_TOKEN_INDEX] + nl_tokens + tokenizer(sentence["value"][len("") :]).input_ids + [im_end] + nl_tokens + else: + _input_id = tokenizer(role).input_ids + nl_tokens + tokenizer(sentence["value"]).input_ids + [im_end] + nl_tokens + input_id += _input_id + if role == "<|im_start|>user": + _target = [im_start] + [IGNORE_INDEX] * (len(_input_id) - 3) + [im_end] + nl_tokens + elif role == "<|im_start|>assistant": + _target = [im_start] + [IGNORE_INDEX] * len(tokenizer(role).input_ids) + _input_id[len(tokenizer(role).input_ids) + 1 : -2] + [im_end] + nl_tokens + else: + raise NotImplementedError + target += _target + assert len(input_id) == len(target) + # input_id += [tokenizer.pad_token_id] * (max_len - len(input_id)) + # target += [IGNORE_INDEX] * (max_len - len(target)) + input_ids.append(input_id) + targets.append(target) + input_ids = torch.tensor(input_ids, dtype=torch.long) + targets = torch.tensor(targets, dtype=torch.long) + + return dict( + input_ids=input_ids, # tensor(bs x seq_len) + labels=targets, # tensor(bs x seq_len) + # attention_mask=input_ids.ne(tokenizer.pad_token_id), # tensor(bs x seq_len) + ) + + +def preprocess_llama3( + sources, + tokenizer: transformers.PreTrainedTokenizer, + has_image: bool = False, + max_len=2048, + system_message: str = "You are a helpful language and vision assistant. You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.", +) -> Dict: + roles = {"human": "<|start_header_id|>user<|end_header_id|>", "gpt": "<|start_header_id|>assistant<|end_header_id|>"} + + eot_id = tokenizer.convert_tokens_to_ids("<|eot_id|>") + nl_tokens = tokenizer("\n").input_ids + + # Apply prompt templates + input_ids, targets = [], [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != roles["human"]: + source = source[1:] + + input_id, target = [], [] + system = tokenizer("<|begin_of_text|>").input_ids + tokenizer("<|start_header_id|>system<|end_header_id|>").input_ids + nl_tokens * 2 + tokenizer(system_message).input_ids + [eot_id] + input_id += system + target += [IGNORE_INDEX] * len(system) + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + if has_image and "" in sentence["value"]: + assert sentence["value"].startswith(""), print(sentence["value"]) + _input_id = tokenizer(role).input_ids + nl_tokens * 2 + [IMAGE_TOKEN_INDEX] + tokenizer(sentence["value"][len("") :]).input_ids + [eot_id] + else: + _input_id = tokenizer(role).input_ids + nl_tokens * 2 + tokenizer(sentence["value"]).input_ids + [eot_id] + input_id += _input_id + if role == "<|start_header_id|>user<|end_header_id|>": + _target = [IGNORE_INDEX] * len(_input_id) + elif role == "<|start_header_id|>assistant<|end_header_id|>": + _target = [IGNORE_INDEX] * (len(tokenizer(role).input_ids) + 2) + _input_id[len(tokenizer(role).input_ids) + 2 : -1] + [eot_id] + else: + raise NotImplementedError + target += _target + assert len(input_id) == len(target), f"{len(input_id)} != {len(target)}" + input_ids.append(input_id) + targets.append(target) + input_ids = torch.tensor(input_ids, dtype=torch.long) + targets = torch.tensor(targets, dtype=torch.long) + + return dict( + input_ids=input_ids, # tensor(bs x seq_len) + labels=targets, # tensor(bs x seq_len) + ) + + +def preprocess_v1(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv = conversation_lib.default_conversation.copy() + roles = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + + if has_image: + input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets = input_ids.clone() + + assert conv.sep_style == conversation_lib.SeparatorStyle.TWO + + # Mask targets + sep = conv.sep + conv.roles[1] + ": " + for conversation, target in zip(conversations, targets): + total_len = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds = conversation.split(conv.sep2) + cur_len = 1 + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2 + else: + round_len = len(tokenizer(rou).input_ids) + instruction_len = len(tokenizer(parts[0]).input_ids) - 2 + + if i != 0 and not tokenizer.legacy and IS_TOKENIZER_GREATER_THAN_0_14: + round_len -= 1 + instruction_len -= 1 + + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + + cur_len += round_len + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f" (ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_mpt(sources, tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + conv = conversation_lib.default_conversation.copy() + roles = {"human": conv.roles[0], "gpt": conv.roles[1]} + + # Apply prompt templates + conversations = [] + for i, source in enumerate(sources): + if roles[source[0]["from"]] != conv.roles[0]: + # Skip the first one if it is not from human + source = source[1:] + + conv.messages = [] + for j, sentence in enumerate(source): + role = roles[sentence["from"]] + assert role == conv.roles[j % 2], f"{i}" + conv.append_message(role, sentence["value"]) + conversations.append(conv.get_prompt()) + + # Tokenize conversations + + if has_image: + input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations], dim=0) + else: + input_ids = tokenizer( + conversations, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ).input_ids + + targets = input_ids.clone() + assert conv.sep_style == conversation_lib.SeparatorStyle.MPT + + # Mask targets + sep = conv.sep + conv.roles[1] + for conversation, target in zip(conversations, targets): + total_len = int(target.ne(tokenizer.pad_token_id).sum()) + + rounds = conversation.split(conv.sep) + re_rounds = [conv.sep.join(rounds[:3])] # system + user + gpt + for conv_idx in range(3, len(rounds), 2): + re_rounds.append(conv.sep.join(rounds[conv_idx : conv_idx + 2])) # user + gpt + cur_len = 1 + target[:cur_len] = IGNORE_INDEX + for i, rou in enumerate(re_rounds): + if rou == "": + break + + parts = rou.split(sep) + if len(parts) != 2: + break + parts[0] += sep + + if has_image: + round_len = len(tokenizer_image_token(rou, tokenizer)) + instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 1 + else: + round_len = len(tokenizer(rou).input_ids) + instruction_len = len(tokenizer(parts[0]).input_ids) - 1 + + if i != 0 and getattr(tokenizer, "legacy", False) and IS_TOKENIZER_GREATER_THAN_0_14: + round_len += 1 + instruction_len += 1 + + target[cur_len : cur_len + instruction_len] = IGNORE_INDEX + + cur_len += round_len + target[cur_len:] = IGNORE_INDEX + + if cur_len < tokenizer.model_max_length: + if cur_len != total_len: + target[:] = IGNORE_INDEX + print(f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}." f"(#turns={len(re_rounds)} ignored)") + + return dict( + input_ids=input_ids, + labels=targets, + ) + + +def preprocess_plain( + sources: Sequence[str], + tokenizer: transformers.PreTrainedTokenizer, +) -> Dict: + # add end signal and concatenate together + conversations = [] + for source in sources: + assert len(source) == 2 + assert DEFAULT_IMAGE_TOKEN in source[0]["value"] + source[0]["value"] = DEFAULT_IMAGE_TOKEN + conversation = source[0]["value"] + source[1]["value"] + conversation_lib.default_conversation.sep + conversations.append(conversation) + # tokenize conversations + input_ids = [tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations] + targets = copy.deepcopy(input_ids) + for target, source in zip(targets, sources): + tokenized_len = len(tokenizer_image_token(source[0]["value"], tokenizer)) + target[:tokenized_len] = IGNORE_INDEX + + return dict(input_ids=input_ids, labels=targets) + + +def preprocess(sources: Sequence[str], tokenizer: transformers.PreTrainedTokenizer, has_image: bool = False) -> Dict: + """ + Given a list of sources, each is a conversation list. This transform: + 1. Add signal '### ' at the beginning each sentence, with end signal '\n'; + 2. Concatenate conversations together; + 3. Tokenize the concatenated conversation; + 4. Make a deepcopy as the target. Mask human words with IGNORE_INDEX. + """ + if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.PLAIN: + return preprocess_plain(sources, tokenizer) + if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.LLAMA_2: + return preprocess_llama_2(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version.startswith("v1"): + return preprocess_v1(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "mpt": + return preprocess_mpt(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "qwen": + return preprocess_qwen(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "gemma": + return preprocess_gemma(sources, tokenizer, has_image=has_image) + if conversation_lib.default_conversation.version == "llama_v3": + return preprocess_llama3(sources, tokenizer, has_image=has_image) + # add end signal and concatenate together + conversations = [] + for source in sources: + header = f"{conversation_lib.default_conversation.system}\n\n" + conversation = _add_speaker_and_signal(header, source) + conversations.append(conversation) + + # tokenize conversations + def get_tokenize_len(prompts): + return [len(tokenizer_image_token(prompt, tokenizer)) for prompt in prompts] + + if has_image: + input_ids = [tokenizer_image_token(prompt, tokenizer, return_tensors="pt") for prompt in conversations] + else: + conversations_tokenized = _tokenize_fn(conversations, tokenizer) + input_ids = conversations_tokenized["input_ids"] + + targets = copy.deepcopy(input_ids) + for target, source in zip(targets, sources): + if has_image: + tokenized_lens = get_tokenize_len([header] + [s["value"] for s in source]) + else: + tokenized_lens = _tokenize_fn([header] + [s["value"] for s in source], tokenizer)["input_ids_lens"] + speakers = [sentence["from"] for sentence in source] + _mask_targets(target, tokenized_lens, speakers) + + return dict(input_ids=input_ids, labels=targets) + + +def load_data(data_path): + if "jsonl" in data_path: + data_list = load_jsonl(data_path) + else: + data_list = load_json(data_path) + return data_list + + +class DPODataset(Dataset): + """Dataset for DPODataset fine-tuning.""" + + def __init__(self, data_path: str, tokenizer: transformers.PreTrainedTokenizer, data_args: DataArguments): + super(DPODataset, self).__init__() + # Handle multiple JSON files specified in the data_path + self.list_data_dict = [] + + if "{" in data_path and "}" in data_path: + base_path, file_pattern = re.match(r"^(.*)\{(.*)\}\.json$", data_path).groups() + file_names = file_pattern.split(",") + rank0_print(f"Loading {file_names} from {base_path}") + data_args.dataset_paths = [] + for file_name in file_names: + data_args.dataset_paths.append(f"{base_path}{file_name}.json") + full_path = f"{base_path}{file_name}.json" + rank0_print(f"Loading {full_path}") + cur_data_dict = load_data(full_path) + rank0_print(f"Loaded {len(cur_data_dict)} samples from {full_path}") + self.list_data_dict.extend(cur_data_dict) + elif data_path.endswith(".yaml"): + with open(data_path, "r") as file: + yaml_data = yaml.safe_load(file) + datasets = yaml_data.get("datasets") + # file should be in the format of: + # datasets: + # - json_path: xxxx1.json + # sampling_strategy: first:1000 + # - json_path: xxxx2.json + # sampling_strategy: end:3000 + # - json_path: xxxx3.json + # sampling_strategy: random:999 + data_args.dataset_paths = [dataset.get("json_path") for dataset in datasets] + for dataset in datasets: + json_path = dataset.get("json_path") + sampling_strategy = dataset.get("sampling_strategy", "all") + sampling_number = None + + rank0_print(f"Loading {json_path} with {sampling_strategy} sampling strategy") + cur_data_dict = load_data(json_path) + + if ":" in sampling_strategy: + sampling_strategy, sampling_number = sampling_strategy.split(":") + if "%" in sampling_number: + sampling_number = math.ceil(int(sampling_number.split("%")[0]) * len(cur_data_dict) / 100) + else: + sampling_number = int(sampling_number) + + # Apply the sampling strategy + if sampling_strategy == "first" and sampling_number is not None: + cur_data_dict = cur_data_dict[:sampling_number] + elif sampling_strategy == "end" and sampling_number is not None: + cur_data_dict = cur_data_dict[-sampling_number:] + elif sampling_strategy == "random" and sampling_number is not None: + random.shuffle(cur_data_dict) + cur_data_dict = cur_data_dict[:sampling_number] + + rank0_print(f"Loaded {len(cur_data_dict)} samples from {json_path}") + self.list_data_dict.extend(cur_data_dict) + else: + data_args.dataset_paths = [data_path] + rank0_print(f"Loading {data_path}") + cur_data_dict = load_data(data_path) + rank0_print(f"Loaded {len(cur_data_dict)} samples from {data_path}") + self.list_data_dict.extend(cur_data_dict) + + rank0_print("Formatting inputs...Skip in lazy mode") + self.tokenizer = tokenizer + self.data_args = data_args + + def __len__(self): + return len(self.list_data_dict) + + @property + def lengths(self): + length_list = [] + for sample in self.list_data_dict: + # Calculate the length of the prompt, answer, chosen, and rejected text + cur_len = len(sample["prompt"].split()) + len(sample["answer"].split()) + len(sample["chosen"].split()) + len(sample["rejected"].split()) + # Add additional tokens if an image is present + img_tokens = 128 if "image" in sample else 0 + length_list.append(cur_len + img_tokens) + return length_list + + @property + def modality_lengths(self): + length_list = [] + for sample in self.list_data_dict: + # Calculate the length of the prompt, answer, chosen, and rejected text + cur_len = len(sample["prompt"].split()) + len(sample["answer"].split()) + len(sample["chosen"].split()) + len(sample["rejected"].split()) + # If the sample includes a video, the length is positive; otherwise, it is negative + cur_len = cur_len if ("video" in sample or "image" in sample) else -cur_len + length_list.append(cur_len) + return length_list + + def process_image(self, image_file): + image_folder = self.data_args.image_folder + processor = self.data_args.image_processor + # print(f"\n\nInspecting the image path, folder = {image_folder}, image={image_file}\n\n") + try: + image = Image.open(os.path.join(image_folder, image_file)).convert("RGB") + except Exception as exn: + print(f"Failed to open image {image_file}. Exception:", exn) + raise exn + + image_size = image.size + if self.data_args.image_aspect_ratio == "highres": + image = process_highres_image(image, self.data_args.image_processor, self.data_args.image_grid_pinpoints) + elif self.data_args.image_aspect_ratio == "anyres" or "anyres" in self.data_args.image_aspect_ratio: + image = process_anyres_image(image, self.data_args.image_processor, self.data_args.image_grid_pinpoints) + elif self.data_args.image_aspect_ratio == "crop_split": + image = process_highres_image_crop_split(image, self.data_args) + elif self.data_args.image_aspect_ratio == "pad": + + def expand2square(pil_img, background_color): + width, height = pil_img.size + if width == height: + return pil_img + elif width > height: + result = Image.new(pil_img.mode, (width, width), background_color) + result.paste(pil_img, (0, (width - height) // 2)) + return result + else: + result = Image.new(pil_img.mode, (height, height), background_color) + result.paste(pil_img, ((height - width) // 2, 0)) + return result + + image = expand2square(image, tuple(int(x * 255) for x in processor.image_mean)) + image = processor.preprocess(image, return_tensors="pt")["pixel_values"][0] + else: + image = processor.preprocess(image, return_tensors="pt")["pixel_values"][0] + return image, image_size, "image" + + def __getitem__(self, i) -> Dict[str, torch.Tensor]: + # TODO: define number of retries somewhere else + num_base_retries = 3 + num_final_retries = 300 + + # try the current sample first + for attempt_idx in range(num_base_retries): + try: + sample = self._get_item(i) + return sample + except Exception as e: + # sleep 1s in case it is a cloud disk issue + print(f"[Try #{attempt_idx}] Failed to fetch sample {i}. Exception:", e) + time.sleep(1) + + # try other samples, in case it is file corruption issue + for attempt_idx in range(num_base_retries): + try: + next_index = min(i + 1, len(self.list_data_dict) - 1) + # sample_idx = random.choice(range(len(self))) + sample = self._get_item(next_index) + return sample + except Exception as e: + # no need to sleep + print(f"[Try other #{attempt_idx}] Failed to fetch sample {next_index}. Exception:", e) + pass + + # still fail, most likely to be path issue or cloud disk issue, retry the same sample for longer + # for attempt_idx in range(num_final_retries): + # try: + # sample = self._get_item(i) + # return sample + # except Exception as e: + # # sleep 1s in case it is a cloud disk issue + # print(f"[Final try #{attempt_idx}] Failed to fetch sample {i}. Exception:", e) + # time.sleep(1) + + # Finally raise exception on failing. + assert False, "Failed to fetch sample." + + def _get_item(self, i) -> Dict[str, torch.Tensor]: + sources = self.list_data_dict[i] + if isinstance(i, int): + sources = [sources] + assert len(sources) == 1, "Don't know why it is wrapped to a list" # FIXME + + suffix = None + if "image" in sources[0]: + image_file = self.list_data_dict[i]["image"] + if type(image_file) is list: + image = [self.process_image(f) for f in image_file] + else: + image = [self.process_image(image_file)] + # sources = preprocess_multimodal(copy.deepcopy([e["conversations"] for e in sources]), self.data_args) + + elif "video" in sources[0]: # FIXME: This logic should be largely improved by Yuanhan. It's too messy now. + video_file = self.list_data_dict[i]["video"] + video_folder = self.data_args.video_folder + video_file = os.path.join(video_folder, video_file) + suffix = video_file.split(".")[-1] + if not os.path.exists(video_file): + print("File {} not exist!".format(video_file)) + + if suffix == "pkl": + video_info = pickle.load(open(video_file, "rb")) + image = torch.from_numpy(video_info["feats"][:, 1:]) + input_prompt = video_info["inputs"].replace("...", "") + # replace the default image token with multiple tokens + input_prompt = input_prompt.replace(DEFAULT_IMAGE_TOKEN, DEFAULT_IMAGE_TOKEN * self.data_args.video_token) + sources, query_prompt = preprocess_multimodal_movie(copy.deepcopy([e["conversations"] for e in sources]), self.data_args, input_prompt) + else: # using videoreader + if "shareVideoGPTV" not in video_file and "liangke" not in video_file: + vr = VideoReader(video_file, ctx=cpu(0)) + total_frame_num = len(vr) + avg_fps = round(vr.get_avg_fps() / self.data_args.video_fps) + frame_idx = [i for i in range(0, total_frame_num, avg_fps)] + if self.data_args.frames_upbound > 0: + if len(frame_idx) > self.data_args.frames_upbound: + uniform_sampled_frames = np.linspace(0, total_frame_num - 1, self.data_args.frames_upbound, dtype=int) + frame_idx = uniform_sampled_frames.tolist() + video = vr.get_batch(frame_idx).asnumpy() + video = np.array(video) + else: + if "liangke" in video_file: + video_file = self.list_data_dict[i]["video"] + frame_files = [os.path.join(video_file, f) for f in os.listdir(video_file) if os.path.isfile(os.path.join(video_file, f))] + frame_files.sort() # Ensure the frames are sorted if they are named sequentially + + # TODO: Hard CODE: Determine the indices for uniformly sampling 10 frames + num_frames_to_sample = 10 + + total_frames = len(frame_files) + + sampled_indices = np.linspace(0, total_frames - 1, num_frames_to_sample, dtype=int) + + # Read and store the sampled frames + video = [] + for idx in sampled_indices: + frame_path = frame_files[idx] + try: + with Image.open(frame_path) as img: + frame = img.convert("RGB") + video.append(frame) + except IOError: + print(f"Failed to read frame at path: {frame_path}") + + processor = self.data_args.image_processor + image = processor.preprocess(video, return_tensors="pt")["pixel_values"] + image = [(image, video[0].size, "video")] + # sources = preprocess_multimodal(copy.deepcopy([e["conversations"] for e in sources]), self.data_args) + + else: + sources = copy.deepcopy([e["conversations"] for e in sources]) + + has_image = ("image" in self.list_data_dict[i]) or ("video" in self.list_data_dict[i]) + # data_dict = preprocess(sources, self.tokenizer, has_image=has_image) + data_dict = copy.deepcopy(self.list_data_dict[i]) # inplace modification following + + if "prompt" in data_dict: + prompt = data_dict["prompt"] + prompt = prompt.replace("", "").strip() + prompt = "\n" + prompt + data_dict["prompt"] = prompt + else: + prompt = None + + if suffix == "pkl": + prompt = [query_prompt] + + # image exist in the data + if "image" in self.list_data_dict[i]: + data_dict["image"] = image + elif "video" in self.list_data_dict[i]: + data_dict["image"] = image + elif self.data_args.is_multimodal: + # image does not exist in the data, but the model is multimodal + crop_size = self.data_args.image_processor.crop_size + data_dict["image"] = [ + (torch.zeros(1, 3, crop_size["height"], crop_size["width"]), (crop_size["width"], crop_size["height"]), "text"), + ] + # prompt exist in the data + data_dict["has_image"] = has_image + return data_dict + + +@dataclass +class DPODataCollator(DPODataCollatorWithPadding): + """Collate examples for DPO fine-tuning.""" + + # tokenizer: transformers.PreTrainedTokenizer + + def collate(self, batch): + # first, pad everything to the same length + # input_ids, labels = tuple([instance[key] for instance in instances] + # for key in ("input_ids", "labels")) + # input_ids = torch.nn.utils.rnn.pad_sequence( + # input_ids, + # batch_first=True, + # padding_value=self.tokenizer.pad_token_id) + # labels = torch.nn.utils.rnn.pad_sequence(labels, + # batch_first=True, + # padding_value=IGNORE_INDEX) + # input_ids = input_ids[:, :self.tokenizer.model_max_length] + # labels = labels[:, :self.tokenizer.model_max_length] + # batch = dict( + # input_ids=input_ids, + # labels=labels, + # attention_mask=input_ids.ne(self.tokenizer.pad_token_id), + # ) + padded_batch = {} + for k in batch[0].keys(): + if k.endswith("_input_ids") or k.endswith("_attention_mask") or k.endswith("_labels"): + # if "prompt" in k: + # to_pad = [torch.LongTensor(ex[k][::-1]) for ex in batch] + # else: + to_pad = [torch.LongTensor(ex[k]) for ex in batch] + if k.endswith("_input_ids"): + padding_value = self.tokenizer.pad_token_id + elif k.endswith("_labels"): + padding_value = self.label_pad_token_id + else: + continue + # elif k.endswith("_attention_mask"): + # padding_value = self.padding_value + # else: + # raise ValueError(f"Unexpected key in batch '{k}'") + + padded_batch[k] = torch.nn.utils.rnn.pad_sequence(to_pad, batch_first=True, padding_value=padding_value) + # for the prompt, flip back so padding is on left side + # if "prompt" in k: + # padded_batch[k] = padded_batch[k].flip(dims=[1]) + else: + padded_batch[k] = [ex[k] for ex in batch] + for k in ["chosen_input_ids", "rejected_input_ids"]: + attn_k = k.replace("input_ids", "attention_mask") + padded_batch[attn_k] = padded_batch[k].ne(self.tokenizer.pad_token_id) + return padded_batch + + def tokenize_batch_element(self, prompt: str, chosen: str, rejected: str, has_image: bool = True) -> Dict: + """Tokenize a single batch element. + + At this stage, we don't convert to PyTorch tensors yet; we just handle the truncation + in case the prompt + chosen or prompt + rejected responses is/are too long. First + we truncate the prompt; if we're still too long, we truncate the chosen/rejected. + + We also create the labels for the chosen/rejected responses, which are of length equal to + the sum of the length of the prompt and the chosen/rejected response, with + label_pad_token_id for the prompt tokens. + """ + # import pdb; pdb.set_trace() + batch = {} + + chosen_sources = make_conv(prompt, chosen) + rejected_sources = make_conv(prompt, rejected) + chosen_data_dict = preprocess([chosen_sources], self.tokenizer, has_image=has_image) + # chosen_data_dict['attention_mask'] = chosen_data_dict["input_ids"].ne(self.tokenizer.pad_token_id) + + rejected_data_dict = preprocess([rejected_sources], self.tokenizer, has_image=has_image) + # rejected_data_dict['attention_mask'] = rejected_data_dict["input_ids"].ne(self.tokenizer.pad_token_id) + + chosen_data_dict = {k: v[0] for k, v in chosen_data_dict.items()} + rejected_data_dict = {k: v[0] for k, v in rejected_data_dict.items()} + + for k, toks in { + "chosen": chosen_data_dict, + "rejected": rejected_data_dict, + }.items(): + for type_key, tokens in toks.items(): + if type_key == "token_type_ids": + continue + batch[f"{k}_{type_key}"] = tokens + return batch + + def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]: + + tokenized_batch = [] + Xs, keys = [], [] + for feature in features: + prompt = feature["prompt"] + chosen = feature["chosen"] + rejected = feature["rejected"] + has_image = feature["has_image"] + # Xs.append(feature[has_X]) + # keys.append(has_X) + + batch_element = self.tokenize_batch_element(prompt, chosen, rejected, has_image=has_image) + tokenized_batch.append(batch_element) + + # return collated batch + padded_batch = self.collate(tokenized_batch) + # import pdb;pdb.set_trace() + if "image" in features[0]: + # instances[1]['image'][0][0].shape + # torch.Size([5, 3, 224, 224]) + images = [instance["image"] for instance in features] + + padded_batch["image_sizes"] = [im[1] for im_list in images for im in im_list] + padded_batch["modalities"] = [im[2] for im_list in images for im in im_list] + images = [im[0] for im_list in images for im in im_list] + # import pdb;pdb.set_trace() + + padded_batch["images"] = images + # padded_batch["images"] =[padded_batch["modalities"], images] + + return padded_batch + + +def make_dpo_data_module(tokenizer: transformers.PreTrainedTokenizer, data_args) -> Dict: + """Make dataset and collator for supervised fine-tuning.""" + train_dataset = DPODataset(tokenizer=tokenizer, data_path=data_args.data_path, data_args=data_args) + return train_dataset + + +def get_model(model_args, training_args, bnb_model_from_pretrained_args): + assert training_args.attn_implementation + if training_args.attn_implementation == "sdpa" and torch.__version__ < "2.1.2": + raise ValueError("The 'sdpa' attention implementation requires torch version 2.1.2 or higher.") + + ######################### Overwrite config ######################### + customized_kwargs = dict() + customized_kwargs.update(bnb_model_from_pretrained_args) + overwrite_config = {} + cfg_pretrained = None + if "qwen" in model_args.model_name_or_path.lower(): + cfg_pretrained = LlavaQwenConfig.from_pretrained(model_args.model_name_or_path) + elif "mistral" in model_args.model_name_or_path.lower() or "zephyr" in model_args.model_name_or_path.lower(): + cfg_pretrained = LlavaMistralConfig.from_pretrained(model_args.model_name_or_path) + elif ( + "wizardlm-2" in model_args.model_name_or_path.lower() + or "vicuna" in model_args.model_name_or_path.lower() + or "llama" in model_args.model_name_or_path.lower() + or "yi" in model_args.model_name_or_path.lower() + or "nous-hermes" in model_args.model_name_or_path.lower() + and "wizard-2" in model_args.model_name_or_path.lower() + ): + cfg_pretrained = LlavaConfig.from_pretrained(model_args.model_name_or_path) + else: + cfg_pretrained = AutoConfig.from_pretrained(model_args.model_name_or_path) + + if model_args.rope_scaling_factor is not None and model_args.rope_scaling_type is not None and cfg_pretrained is not None: + overwrite_config["rope_scaling"] = { + "factor": model_args.rope_scaling_factor, + "type": model_args.rope_scaling_type, + } + if training_args.model_max_length is None: + training_args.model_max_length = cfg_pretrained.max_position_embeddings * model_args.rope_scaling_factor + overwrite_config["max_sequence_length"] = training_args.model_max_length + assert training_args.model_max_length == int(cfg_pretrained.max_position_embeddings * model_args.rope_scaling_factor), print( + f"model_max_length: {training_args.model_max_length}, max_position_embeddings: {cfg_pretrained.max_position_embeddings}, rope_scaling_factor: {model_args.rope_scaling_factor}" + ) + # overwrite_config["max_sequence_length"] = model_args.max_sequence_length + # overwrite_config["tokenizer_model_max_length"] = model_args.tokenizer_model_max_length + + if model_args.mm_spatial_pool_stride is not None and model_args.mm_spatial_pool_out_channels is not None and model_args.mm_spatial_pool_mode is not None and model_args.mm_resampler_type is not None and cfg_pretrained is not None: + overwrite_config["mm_resampler_type"] = model_args.mm_resampler_type + overwrite_config["mm_spatial_pool_stride"] = model_args.mm_spatial_pool_stride + overwrite_config["mm_spatial_pool_out_channels"] = model_args.mm_spatial_pool_out_channels + overwrite_config["mm_spatial_pool_mode"] = model_args.mm_spatial_pool_mode + + if overwrite_config: + rank0_print(f"Overwriting config with {overwrite_config}") + for k, v in overwrite_config.items(): + setattr(cfg_pretrained, k, v) + + customized_kwargs["config"] = cfg_pretrained + + ######################### Finish Overwrite ########################### + + ref_model = None + if model_args.model_class_name is not None: + actual_model_class_name = f"{model_args.model_class_name}ForCausalLM" + model_class = getattr(transformers, actual_model_class_name) + rank0_print(f"Using model class {model_class} from {model_args.model_class_name}") + model = model_class.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + elif model_args.vision_tower is not None: + if "mixtral" in model_args.model_name_or_path.lower(): + model = LlavaMixtralForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + from transformers.models.mixtral.modeling_mixtral import MixtralSparseMoeBlock + + deepspeed.utils.set_z3_leaf_modules(model, [MixtralSparseMoeBlock]) + elif "mistral" in model_args.model_name_or_path.lower() or "zephyr" in model_args.model_name_or_path.lower(): + model = LlavaMistralForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + elif ( + "wizardlm-2" in model_args.model_name_or_path.lower() + or "vicuna" in model_args.model_name_or_path.lower() + or "llama" in model_args.model_name_or_path.lower() + or "yi" in model_args.model_name_or_path.lower() + or "nous-hermes" in model_args.model_name_or_path.lower() + and "wizard-2" in model_args.model_name_or_path.lower() + ): + model = LlavaLlamaForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + + if "zero3" in training_args.deepspeed: + rank0_print("#### Initialize reference model #####") + ref_model = LlavaLlamaForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + + elif "qwen" in model_args.model_name_or_path.lower() or "quyen" in model_args.model_name_or_path.lower(): + if "moe" in model_args.model_name_or_path.lower(): + model = LlavaQwenMoeForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + from transformers.models.qwen2_moe.modeling_qwen2_moe import Qwen2MoeSparseMoeBlock + + deepspeed.utils.set_z3_leaf_modules(model, [Qwen2MoeSparseMoeBlock]) + else: + model = LlavaQwenForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + + if "zero3" in training_args.deepspeed: + rank0_print("#### Initialize reference model #####") + ref_model = LlavaQwenForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + + elif "gemma" in model_args.model_name_or_path.lower(): + model = LlavaGemmaForCausalLM.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + attn_implementation=training_args.attn_implementation, + torch_dtype=(torch.bfloat16 if training_args.bf16 else None), + low_cpu_mem_usage=False, + **customized_kwargs, + ) + else: + raise ValueError(f"Unknown model class {model_args}") + else: + model = transformers.LlamaForCausalLM.from_pretrained( + model_args.model_name_or_path, cache_dir=training_args.cache_dir, attn_implementation=training_args.attn_implementation, torch_dtype=(torch.bfloat16 if training_args.bf16 else None), **customized_kwargs + ) + return model, ref_model + + +def train(attn_implementation=None): + global local_rank + + parser = transformers.HfArgumentParser((ModelArguments, DataArguments, TrainingArguments)) + model_args, data_args, training_args = parser.parse_args_into_dataclasses() + + if training_args.verbose_logging: + rank0_print(f"Inspecting experiment hyperparameters:\n") + rank0_print(f"model_args = {vars(model_args)}\n\n") + rank0_print(f"data_args = {vars(data_args)}\n\n") + rank0_print(f"training_args = {vars(training_args)}\n\n") + # rank0_print(f"evaluation_args = {vars(evaluation_args)}\n\n") + + local_rank = training_args.local_rank + compute_dtype = torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32) + + bnb_model_from_pretrained_args = {} + if training_args.bits in [4, 8]: + from transformers import BitsAndBytesConfig + + bnb_model_from_pretrained_args.update( + dict( + device_map={"": training_args.device}, + load_in_4bit=training_args.bits == 4, + load_in_8bit=training_args.bits == 8, + quantization_config=BitsAndBytesConfig( + load_in_4bit=training_args.bits == 4, + load_in_8bit=training_args.bits == 8, + llm_int8_threshold=6.0, + llm_int8_has_fp16_weight=False, + bnb_4bit_compute_dtype=compute_dtype, + bnb_4bit_use_double_quant=training_args.double_quant, + bnb_4bit_quant_type=training_args.quant_type, # {'fp4', 'nf4'} + ), + ) + ) + + model, ref_model = get_model(model_args, training_args, bnb_model_from_pretrained_args) + model.config.use_cache = False + + if model_args.freeze_backbone: + model.model.requires_grad_(False) + + if training_args.bits in [4, 8]: + from peft import prepare_model_for_kbit_training + + model.config.torch_dtype = torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32) + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing) + + if training_args.gradient_checkpointing: + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + if ref_model is not None: + ref_model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + if ref_model is not None: + ref_model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + if training_args.lora_enable: + from peft import LoraConfig, get_peft_model + + lora_config = LoraConfig( + r=training_args.lora_r, + lora_alpha=training_args.lora_alpha, + target_modules=find_all_linear_names(model), + lora_dropout=training_args.lora_dropout, + bias=training_args.lora_bias, + task_type="CAUSAL_LM", + ) + if training_args.bits == 16: + if training_args.bf16: + model.to(torch.bfloat16) + if training_args.fp16: + model.to(torch.float16) + rank0_print("Adding LoRA adapters...") + model = get_peft_model(model, lora_config) + + if "mpt" in model_args.model_name_or_path: + tokenizer = transformers.AutoTokenizer.from_pretrained(model_args.model_name_or_path, cache_dir=training_args.cache_dir, model_max_length=training_args.model_max_length, padding_side="right") + elif "mistral" in model_args.model_name_or_path.lower() or "mixtral" in model_args.model_name_or_path.lower() or "zephyr" in model_args.model_name_or_path.lower(): + tokenizer = transformers.AutoTokenizer.from_pretrained(model_args.model_name_or_path, cache_dir=training_args.cache_dir, model_max_length=training_args.model_max_length, padding_side="left") + elif "qwen" in model_args.model_name_or_path.lower(): + tokenizer = transformers.AutoTokenizer.from_pretrained(model_args.model_name_or_path, cache_dir=training_args.cache_dir, model_max_length=training_args.model_max_length, padding_side="right") + else: # for all other models + tokenizer = transformers.AutoTokenizer.from_pretrained( + model_args.model_name_or_path, + cache_dir=training_args.cache_dir, + model_max_length=training_args.model_max_length, + padding_side="right", + use_fast=False, + ) + + rank0_print(f"Prompt version: {model_args.version}") + if model_args.version == "v0": + if tokenizer.pad_token is None: + smart_tokenizer_and_embedding_resize( + special_tokens_dict=dict(pad_token="[PAD]"), + tokenizer=tokenizer, + model=model, + ) + elif model_args.version == "v0.5": + tokenizer.pad_token = tokenizer.unk_token + else: + if tokenizer.unk_token is not None: + tokenizer.pad_token = tokenizer.unk_token + if model_args.version in conversation_lib.conv_templates: + conversation_lib.default_conversation = conversation_lib.conv_templates[model_args.version] + else: + conversation_lib.default_conversation = conversation_lib.conv_templates["vicuna_v1"] + + if model_args.vision_tower is not None: + model.get_model().initialize_vision_modules(model_args=model_args, fsdp=training_args.fsdp) + + vision_tower = model.get_vision_tower() + vision_tower.to(dtype=torch.bfloat16 if training_args.bf16 else torch.float16, device=training_args.device) + + data_args.image_processor = vision_tower.image_processor + data_args.is_multimodal = True + + model.config.image_aspect_ratio = data_args.image_aspect_ratio + if data_args.image_grid_pinpoints is not None: + # for input like "(1x1)...(3x3)", convert to [(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)] + if "x" in data_args.image_grid_pinpoints and "..." in data_args.image_grid_pinpoints: + vis_encoder_size = data_args.image_processor.size[0] + matches = re.findall(r"\((\d+)x(\d+)\)", data_args.image_grid_pinpoints) + range_start = tuple(map(int, matches[0])) + range_end = tuple(map(int, matches[-1])) + grid_pinpoints = [(i, j) for i in range(range_start[0], range_end[0] + 1) for j in range(range_start[1], range_end[1] + 1)] + grid_pinpoints = [[dim * vis_encoder_size for dim in pair] for pair in grid_pinpoints] + data_args.image_grid_pinpoints = grid_pinpoints + elif "x" in data_args.image_grid_pinpoints: + vis_encoder_size = data_args.image_processor.size[0] + assert vis_encoder_size in [224, 336, 384, 448, 512], "vis_encoder_size should be in [224, 336, 384, 448, 512]" + grid_pinpoints = data_args.image_grid_pinpoints.replace(" ", "").replace("x", ",")[1:-1].split("),(") + data_args.image_grid_pinpoints = [[int(x) * vis_encoder_size for x in item.split(",")] for item in grid_pinpoints] + else: + data_args.image_grid_pinpoints = ast.literal_eval(data_args.image_grid_pinpoints) # for backward compatibility + model.config.image_grid_pinpoints = data_args.image_grid_pinpoints + model.config.image_crop_resolution = data_args.image_crop_resolution + model.config.image_split_resolution = data_args.image_split_resolution + model.config.tokenizer_padding_side = tokenizer.padding_side + model.config.tokenizer_model_max_length = tokenizer.model_max_length + + ### Deciding train which part of the model + if model_args.mm_tunable_parts is None: # traditional way of deciding which part to train + model.config.tune_mm_mlp_adapter = training_args.tune_mm_mlp_adapter = model_args.tune_mm_mlp_adapter + model.config.tune_mm_vision_resampler = training_args.tune_mm_vision_resampler = model_args.tune_mm_vision_resampler + if model_args.tune_mm_mlp_adapter or model_args.tune_mm_vision_resampler: + model.requires_grad_(False) + if model_args.tune_mm_mlp_adapter: + for p in model.get_model().mm_projector.parameters(): + p.requires_grad = True + if model_args.tune_mm_vision_resampler: + for p in model.get_model().vision_resampler.parameters(): + p.requires_grad = True + + model.config.freeze_mm_mlp_adapter = training_args.freeze_mm_mlp_adapter + if training_args.freeze_mm_mlp_adapter: + for p in model.get_model().mm_projector.parameters(): + p.requires_grad = False + + model.config.freeze_mm_vision_resampler = training_args.freeze_mm_vision_resampler + if training_args.freeze_mm_vision_resampler: + for p in model.get_model().vision_resampler.parameters(): + p.requires_grad = False + + model.config.unfreeze_mm_vision_tower = model_args.unfreeze_mm_vision_tower + if model_args.unfreeze_mm_vision_tower: + vision_tower.requires_grad_(True) + else: + vision_tower.requires_grad_(False) + + else: + rank0_print(f"Using mm_tunable_parts: {model_args.mm_tunable_parts}") + model.config.mm_tunable_parts = training_args.mm_tunable_parts = model_args.mm_tunable_parts + # Set the entire model to not require gradients by default + model.requires_grad_(False) + vision_tower.requires_grad_(False) + model.get_model().mm_projector.requires_grad_(False) + model.get_model().vision_resampler.requires_grad_(False) + # Parse the mm_tunable_parts to decide which parts to unfreeze + tunable_parts = model_args.mm_tunable_parts.split(",") + if "mm_mlp_adapter" in tunable_parts: + for p in model.get_model().mm_projector.parameters(): + p.requires_grad = True + if "mm_vision_resampler" in tunable_parts: + for p in model.get_model().vision_resampler.parameters(): + p.requires_grad = True + if "mm_vision_tower" in tunable_parts: + for name, param in model.named_parameters(): + if "vision_tower" in name: + param.requires_grad_(True) + if "mm_language_model" in tunable_parts: + for name, param in model.named_parameters(): + if "vision_tower" not in name and "mm_projector" not in name and "vision_resampler" not in name: + param.requires_grad_(True) + + total_params = sum(p.ds_numel if hasattr(p, "ds_numel") else p.numel() for p in model.parameters()) + trainable_params = sum(p.ds_numel if hasattr(p, "ds_numel") else p.numel() for p in model.parameters() if p.requires_grad) + rank0_print(f"Total parameters: ~{total_params/1e6:.2f} MB)") + rank0_print(f"Trainable parameters: ~{trainable_params/1e6:.2f} MB)") + if training_args.bits in [4, 8]: + model.get_model().mm_projector.to(dtype=compute_dtype, device=training_args.device) + + model.config.mm_use_im_start_end = data_args.mm_use_im_start_end = model_args.mm_use_im_start_end + model.config.mm_projector_lr = training_args.mm_projector_lr + model.config.mm_vision_tower_lr = training_args.mm_vision_tower_lr + training_args.use_im_start_end = model_args.mm_use_im_start_end + model.config.mm_use_im_patch_token = model_args.mm_use_im_patch_token + model.initialize_vision_tokenizer(model_args, tokenizer=tokenizer) + + if ref_model is not None: + ref_model.get_model().initialize_vision_modules(model_args=model_args, fsdp=training_args.fsdp) + ref_vision_tower = ref_model.get_vision_tower() + ref_vision_tower.to(dtype=torch.bfloat16 if training_args.bf16 else torch.float16, device=training_args.device) + ref_model.config.image_aspect_ratio = data_args.image_aspect_ratio + ref_model.config.image_grid_pinpoints = data_args.image_grid_pinpoints + ref_model.config.image_crop_resolution = data_args.image_crop_resolution + ref_model.config.image_split_resolution = data_args.image_split_resolution + ref_model.config.tokenizer_padding_side = tokenizer.padding_side + ref_model.config.tokenizer_model_max_length = tokenizer.model_max_length + ref_model.config.mm_use_im_start_end = data_args.mm_use_im_start_end + ref_model.config.mm_use_im_patch_token = model_args.mm_use_im_patch_token + ref_model.initialize_vision_tokenizer(model_args, tokenizer=tokenizer) + parameter_names = [n for n, _ in ref_model.named_parameters()] + for param_name in parameter_names: + param = ref_model.get_parameter(param_name) + param.requires_grad = False + ref_model.eval() + + if training_args.bits in [4, 8]: + from peft.tuners.lora import LoraLayer + + for name, module in model.named_modules(): + if isinstance(module, LoraLayer): + if training_args.bf16: + module = module.to(torch.bfloat16) + if "norm" in name: + module = module.to(torch.float32) + if "lm_head" in name or "embed_tokens" in name: + if hasattr(module, "weight"): + if training_args.bf16 and module.weight.dtype == torch.float32: + module = module.to(torch.bfloat16) + + train_dataset = make_dpo_data_module(tokenizer=tokenizer, data_args=data_args) + data_collator = DPODataCollator( + tokenizer, + label_pad_token_id=IGNORE_INDEX, + pad_token_id=tokenizer.pad_token_id, + ) + + trainer = LLaVADPOTrainer( + model, + ref_model, + args=training_args, + dpo_alpha=training_args.dpo_alpha, + beta=training_args.beta, + gamma=training_args.gamma, + train_dataset=train_dataset, + eval_dataset=None, + data_collator=data_collator, + tokenizer=tokenizer, + max_length=training_args.model_max_length, + generate_during_eval=False, # training_args.generate_during_eval, + precompute_ref_log_probs=training_args.precompute_ref_log_probs, + ) + + if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")): + trainer.train(resume_from_checkpoint=True) + else: + trainer.train() + trainer.save_state() + + model.config.use_cache = True + + if training_args.lora_enable: + state_dict = get_peft_state_maybe_zero_3(model.named_parameters(), training_args.lora_bias) + non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(model.named_parameters()) + if training_args.local_rank == 0 or training_args.local_rank == -1: + if hasattr(model, "config"): + model.config.save_pretrained(training_args.output_dir) + if hasattr(model, "generation_config"): + model.generation_config.save_pretrained(training_args.output_dir) + model.save_pretrained(training_args.output_dir, state_dict=state_dict) + torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, "non_lora_trainables.bin")) + else: + safe_save_model_for_hf_trainer(trainer=trainer, output_dir=training_args.output_dir) + + rank0_print(f"Model saved to {training_args.output_dir}") + + +if __name__ == "__main__": + train() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train_mem.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train_mem.py new file mode 100644 index 0000000000000000000000000000000000000000..6135ca4134a25d22eb40d994499ba564b9673f34 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/train/train_mem.py @@ -0,0 +1,4 @@ +from llava.train.train import train + +if __name__ == "__main__": + train() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1e004c33bc503d213df619dec948f39b4c13e53d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/llava/utils.py @@ -0,0 +1,198 @@ +import datetime +import logging +import logging.handlers +import os +import sys +import numpy as np + +import requests + +from llava.constants import LOGDIR + +server_error_msg = "**NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE.**" +moderation_msg = "I am sorry. Your input may violate our content moderation guidelines. Please avoid using harmful or offensive content." + +handler = None + +import torch.distributed as dist + +try: + import av + from decord import VideoReader, cpu +except ImportError: + print("Please install pyav to use video processing functions.") + +def process_video_with_decord(video_file, data_args): + vr = VideoReader(video_file, ctx=cpu(0), num_threads=1) + total_frame_num = len(vr) + video_time = total_frame_num / vr.get_avg_fps() + avg_fps = round(vr.get_avg_fps() / data_args.video_fps) + frame_idx = [i for i in range(0, total_frame_num, avg_fps)] + frame_time = [i/avg_fps for i in frame_idx] + + + if data_args.frames_upbound > 0: + if len(frame_idx) > data_args.frames_upbound or data_args.force_sample: + uniform_sampled_frames = np.linspace(0, total_frame_num - 1, data_args.frames_upbound, dtype=int) + frame_idx = uniform_sampled_frames.tolist() + frame_time = [i/vr.get_avg_fps() for i in frame_idx] + + video = vr.get_batch(frame_idx).asnumpy() + frame_time = ",".join([f"{i:.2f}s" for i in frame_time]) + + num_frames_to_sample = num_frames = len(frame_idx) + # https://github.com/dmlc/decord/issues/208 + vr.seek(0) + return video, video_time, frame_time, num_frames_to_sample + +def process_video_with_pyav(video_file, data_args): + container = av.open(video_file) + # !!! This is the only difference. Using auto threading + container.streams.video[0].thread_type = "AUTO" + + video_frames = [] + for packet in container.demux(): + if packet.stream.type == 'video': + for frame in packet.decode(): + video_frames.append(frame) + total_frame_num = len(video_frames) + video_time = video_frames[-1].time + avg_fps = round(total_frame_num / video_time / data_args.video_fps) + frame_idx = [i for i in range(0, total_frame_num, avg_fps)] + + if data_args.frames_upbound > 0: + if len(frame_idx) > data_args.frames_upbound: + uniform_sampled_frames = np.linspace(0, total_frame_num - 1, data_args.frames_upbound, dtype=int) + frame_idx = uniform_sampled_frames.tolist() + + + frames = [video_frames[i] for i in frame_idx] + return np.stack([x.to_ndarray(format="rgb24") for x in frames]) + + +def rank0_print(*args): + if dist.is_initialized(): + if dist.get_rank() == 0: + print(f"Rank {dist.get_rank()}: ", *args) + else: + print(*args) + + +def rank_print(*args): + if dist.is_initialized(): + print(f"Rank {dist.get_rank()}: ", *args) + else: + print(*args) + +def build_logger(logger_name, logger_filename): + global handler + + formatter = logging.Formatter( + fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + + # Set the format of root handlers + if not logging.getLogger().handlers: + logging.basicConfig(level=logging.INFO) + logging.getLogger().handlers[0].setFormatter(formatter) + + # Redirect stdout and stderr to loggers + stdout_logger = logging.getLogger("stdout") + stdout_logger.setLevel(logging.INFO) + sl = StreamToLogger(stdout_logger, logging.INFO) + sys.stdout = sl + + stderr_logger = logging.getLogger("stderr") + stderr_logger.setLevel(logging.ERROR) + sl = StreamToLogger(stderr_logger, logging.ERROR) + sys.stderr = sl + + # Get logger + logger = logging.getLogger(logger_name) + logger.setLevel(logging.INFO) + + # Add a file handler for all loggers + if handler is None: + os.makedirs(LOGDIR, exist_ok=True) + filename = os.path.join(LOGDIR, logger_filename) + handler = logging.handlers.TimedRotatingFileHandler(filename, when="D", utc=True) + handler.setFormatter(formatter) + + for name, item in logging.root.manager.loggerDict.items(): + if isinstance(item, logging.Logger): + item.addHandler(handler) + + return logger + + +class StreamToLogger(object): + """ + Fake file-like stream object that redirects writes to a logger instance. + """ + + def __init__(self, logger, log_level=logging.INFO): + self.terminal = sys.stdout + self.logger = logger + self.log_level = log_level + self.linebuf = "" + + def __getattr__(self, attr): + return getattr(self.terminal, attr) + + def write(self, buf): + temp_linebuf = self.linebuf + buf + self.linebuf = "" + for line in temp_linebuf.splitlines(True): + # From the io.TextIOWrapper docs: + # On output, if newline is None, any '\n' characters written + # are translated to the system default line separator. + # By default sys.stdout.write() expects '\n' newlines and then + # translates them so this is still cross platform. + if line[-1] == "\n": + self.logger.log(self.log_level, line.rstrip()) + else: + self.linebuf += line + + def flush(self): + if self.linebuf != "": + self.logger.log(self.log_level, self.linebuf.rstrip()) + self.linebuf = "" + + +def disable_torch_init(): + """ + Disable the redundant torch default initialization to accelerate model creation. + """ + import torch + + setattr(torch.nn.Linear, "reset_parameters", lambda self: None) + setattr(torch.nn.LayerNorm, "reset_parameters", lambda self: None) + + +def violates_moderation(text): + """ + Check whether the text violates OpenAI moderation API. + """ + url = "https://api.openai.com/v1/moderations" + headers = {"Content-Type": "application/json", "Authorization": "Bearer " + os.environ["OPENAI_API_KEY"]} + text = text.replace("\n", "") + data = "{" + '"input": ' + f'"{text}"' + "}" + data = data.encode("utf-8") + try: + ret = requests.post(url, headers=headers, data=data, timeout=5) + flagged = ret.json()["results"][0]["flagged"] + except requests.exceptions.RequestException as e: + print(f"######################### Moderation Error: {e} #########################") + flagged = False + except KeyError as e: + print(f"######################### Moderation Error: {e} #########################") + flagged = False + + return flagged + + +def pretty_print_semaphore(semaphore): + if semaphore is None: + return "None" + return f"Semaphore(value={semaphore._value}, locked={semaphore.locked()})" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/2d_hist.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/2d_hist.py new file mode 100644 index 0000000000000000000000000000000000000000..3592348e2b4dec86789a5abc4ada56f6f943b623 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/2d_hist.py @@ -0,0 +1,132 @@ +import json +import os +from PIL import Image +from tqdm import tqdm +import matplotlib.pyplot as plt +import numpy as np +from multiprocessing import Pool +import functools +import argparse + + +def load_data(json_path): + with open(json_path, "r") as f: + return json.load(f) + + +def filter_data(data): + filtered_data = [item for item in data if "image" in item] + return filtered_data + + +def calculate_image_dimension(image_path, images_folder): + full_path = os.path.join(images_folder, image_path) + try: + with Image.open(full_path) as img: + width, height = img.size + return width, height + except Exception as e: + print(f"Error opening {full_path}: {e}") + return None, None + + +def calculate_image_dimensions_multiprocess(filtered_data, images_folder, num_processes=256): + image_paths = [] + for item in filtered_data: + if isinstance(item["image"], list): + image_paths.extend(item["image"]) + else: + image_paths.append(item["image"]) + + with Pool(num_processes) as p: + dimensions = list( + tqdm( + p.imap(functools.partial(calculate_image_dimension, images_folder=images_folder), image_paths), + total=len(image_paths), + desc="Calculating image dimensions", + ) + ) + widths, heights = zip(*[dim for dim in dimensions if dim[0] is not None]) + return list(widths), list(heights) + + +def tokenize(text): + return text.split() + + +def calculate_tokenized_lengths(data): + lengths = [] + for item in tqdm(data, desc="Tokenizing conversations"): + for conversation in item["conversations"]: + tokenized_value = tokenize(conversation["value"]) + lengths.append(len(tokenized_value)) + return lengths + + +def main(): + parser = argparse.ArgumentParser(description="Process data for LLaVA_Next project.") + parser.add_argument( + "--json_path", + type=str, + help="Path to the JSON file containing data.", + default="/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_ofa_DEMON-FULL.json", + ) + parser.add_argument( + "--images_folder", + type=str, + default="/mnt/bn/vl-research/data/llava_data", + help="Path to the folder containing images.", + ) + args = parser.parse_args() + + llava_instruct_name = os.path.basename(args.json_path).replace(".json", "") + images_folder = args.images_folder + + data = load_data(args.json_path) + filtered_data = filter_data(data) + + print(f"Total data items: {len(data)}, Filtered data items: {len(filtered_data)}") + widths, heights = calculate_image_dimensions_multiprocess(filtered_data, images_folder) + max_width, max_height = max(widths), max(heights) + print(f"Max width: {max_width}, Max height: {max_height}") + + tokenized_lengths = calculate_tokenized_lengths(filtered_data) + + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 12)) + + # Plot 2D histogram + widths_bins = [min(widths), max(widths) + 1] if min(widths) == max(widths) else np.arange(min(widths), max(widths) + 100, 100) + heights_bins = [min(heights), max(heights) + 1] if min(heights) == max(heights) else np.arange(min(heights), max(heights) + 100, 100) + + h, xedges, yedges, image = ax1.hist2d(widths, heights, bins=[widths_bins, heights_bins], cmap=plt.cm.jet, density=True) + fig.colorbar(image, ax=ax1) + ax1.set_xlabel("Width") + ax1.set_ylabel("Height") + ax1.set_title( + f"dist_{llava_instruct_name}_2d_w_h\nMax width: {max(widths)}, Max height: {max(heights)}", + fontsize=10, + ) + + # Plot histogram + hist, bin_edges = np.histogram(tokenized_lengths, bins=np.arange(0, max(tokenized_lengths) + 10, 10)) + bins = np.arange(0, max(tokenized_lengths) + 10, 10) + ax2.bar(bin_edges[:-1], hist, width=7, edgecolor="black", log=True) + + # Display every nth label on the x-axis + n = 8 # Adjust this value to control the number of labels displayed + ticks = bins[::n] + tick_labels = [int(tick) for tick in ticks] + ax2.set_xticks(ticks) + ax2.set_xticklabels(tick_labels, rotation=90, fontsize=8) + + ax2.set_xlim(min(bin_edges), max(bin_edges)) + ax2.set_xlabel("Tokenized Length") + ax2.set_ylabel("Count (log scale)") + ax2.set_title(f"dist_{llava_instruct_name}_tokenized_length", fontsize=8) + + plt.tight_layout() + plt.savefig(f"./dist_{llava_instruct_name}_combined.png") + + +if __name__ == "__main__": + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/data_checker.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/data_checker.py new file mode 100644 index 0000000000000000000000000000000000000000..9d145ca477cab808599abd0476b6a1012019748f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/data_checker.py @@ -0,0 +1,364 @@ +import json +import os +from tqdm import tqdm +from multiprocessing import Pool, cpu_count +import yaml + + +class DataProcessor: + def __init__(self, file_path, image_root, video_root): + self.file_path = file_path + self.image_root = image_root + self.data = None + self.video_root = video_root + self.load_data() + + def load_data(self): + if self.file_path.endswith(".json"): + with open(self.file_path, "r") as f: + self.data = json.load(f) + elif self.file_path.endswith(".yaml"): + with open(self.file_path, "r") as f: + self.data = yaml.safe_load(f) + elif self.file_path.endswith(".jsonl"): + with open(self.file_path, "r") as f: + self.data = [json.loads(line) for line in f.readlines()] + else: + raise ValueError("Unsupported file format") + + def load_json_data(self, json_path): + if json_path.endswith(".jsonl"): + cur_data_dict = [] + with open(json_path, "r") as json_file: + for line in json_file: + cur_data_dict.append(json.loads(line.strip())) + return cur_data_dict + elif json_path.endswith(".json"): + with open(json_path, "r") as f: + return json.load(f) + else: + raise ValueError("Unsupported file format") + + def check_image_existence(self, data): + if "image" in data: + if type(data["image"]) == list: + images = data["image"] + else: + images = [data["image"]] + + for image in images: + full_image_path = os.path.join(self.image_root, image) + if not os.path.exists(full_image_path): + print(f"WARNING!!! {full_image_path} not exists !!!") + + if "video" in data: + full_video_path = os.path.join(self.video_root, data["video"]) + if not os.path.exists(full_video_path): + print(f"WARNING!!! {full_video_path} not exists !!!") + + # if data["conversations"][0]["value"].count("") > 1: + # print(f"WARNING!!! {data['conversations'][0]['value']} has more than one !!!") + + def check_item_structure(self, item): + if not all(key in item for key in ["conversations"]): + print(f"WARNING!!! Item {item.get('id', 'unknown')} is missing required fields!") + return False + + conversations = item["conversations"] + if not isinstance(conversations, list) or len(conversations) < 2 or len(conversations) % 2 != 0: + print(f"WARNING!!! Item {item['id']} has invalid conversations structure!") + return False + + for i, conv in enumerate(conversations): + if not all(key in conv for key in ["from", "value"]): + print(f"WARNING!!! Item {item['id']} has invalid conversation format!") + return False + + expected_from = "human" if i % 2 == 0 else "gpt" + if conv["from"] != expected_from: + print(f"WARNING!!! Item {item['id']} has incorrect conversation order!") + return False + + return True + + def check_image_and_structure(self, item): + if not self.check_item_structure(item): + return + + # self.check_image_existence(item) + + def process_images(self): + if isinstance(self.data, list): + args = [d for d in self.data] + with Pool(processes=cpu_count()) as pool: + list(tqdm(pool.imap(self.check_image_and_structure, args), total=len(self.data))) + elif isinstance(self.data, dict): + for d in self.data["datasets"]: + dd_json_path = d["json_path"] + data = self.load_json_data(dd_json_path) + args = [d for d in data] + with Pool(processes=cpu_count()) as pool: + list(tqdm(pool.imap(self.check_image_and_structure, args), total=len(data), desc=f"Processing {dd_json_path}")) + + def count_items(self): + if isinstance(self.data, list): # Assuming JSON data loaded directly + return len(self.data) + elif isinstance(self.data, dict): # Assuming YAML data loaded + total_items_count = 0 + for d in self.data["datasets"]: + dd_json_path = d["json_path"] + data = self.load_json_data(dd_json_path) + current_items_count = len(data) + + sampling_strategy = d["sampling_strategy"] + try: + if sampling_strategy != "all": + percentage = float(sampling_strategy.split(":")[-1].replace("%", "")) / 100.0 + else: + percentage = 1.0 + except Exception as e: + print(f"Error: {e}") + percentage = 1.0 + + sampling_count = int(current_items_count * percentage) + total_items_count += sampling_count + print(f"{dd_json_path}: {sampling_count}") + return total_items_count + + def stat_data(self): + if isinstance(self.data, dict): + cur_lens_list = [] + single_image_count = 0 + multiple_image_count = 0 + video_count = 0 + total_count = 0 + text_count = 0 + max_tokens_item = None + max_tokens = 0 + + for d in self.data["datasets"]: + dd_json_path = d["json_path"] + data = self.load_json_data(dd_json_path) + sampling_strategy = d["sampling_strategy"] + + try: + if sampling_strategy != "all": + percentage = float(sampling_strategy.split(":")[-1].replace("%", "")) / 100.0 + else: + percentage = 1.0 + except Exception as e: + print(f"Error parsing sampling strategy: {e}") + percentage = 1.0 + + sampled_count = int(len(data) * percentage) + print(f"{dd_json_path}: {sampled_count} (sampled from {len(data)})") + + for item in data[:sampled_count]: + conversations = item["conversations"] + cur_len = sum([len(conv["value"].split()) for conv in conversations]) + cur_lens_list.append(cur_len) + + if cur_len > max_tokens: + max_tokens = cur_len + max_tokens_item = item + + total_count += 1 + if "image" in item: + if isinstance(item["image"], list): + if len(item["image"]) > 1: + multiple_image_count += 1 + else: + single_image_count += 1 + else: + single_image_count += 1 + elif "video" in item: + video_count += 1 + else: + text_count += 1 + + print(f"Max length: {max(cur_lens_list)}, Min length: {min(cur_lens_list)}, Average length: {sum(cur_lens_list) / len(cur_lens_list)}") + print(f"Total items: {total_count}") + print(f"Text items: {text_count} ({text_count/total_count*100:.2f}%)") + print(f"Single image items: {single_image_count} ({single_image_count/total_count*100:.2f}%)") + print(f"Multiple image items: {multiple_image_count} ({multiple_image_count/total_count*100:.2f}%)") + print(f"Video items: {video_count} ({video_count/total_count*100:.2f}%)") + + print("\nItem with the largest number of tokens:") + print(f"Token count: {max_tokens}") + print("Item content:") + print(json.dumps(max_tokens_item, indent=2)) + + def filter_data(self): + if isinstance(self.data, dict): + for d in self.data["datasets"]: + dd_json_path = d["json_path"] + print(f"Processing {dd_json_path}") + data = self.load_json_data(dd_json_path) + + filtered_data = [] + mismatch_data = [] + mismatch_flag = False + for item in data: + try: + if "image" in item: + num_image = len(item["image"]) if isinstance(item["image"], list) else 1 + else: + num_image = 0 + + if "video" in item: + num_video = len(item["video"]) if isinstance(item["video"], list) else 1 + else: + num_video = 0 + + num_visuals = num_image + num_video + conv_text = "" + for conv in item["conversations"]: + conv_text += conv["value"] + + num_img_token_appearance = conv_text.count("") + if len(conv_text) == 0: + print(f"Conversation text is empty for {item}") + + if num_img_token_appearance == num_visuals or num_img_token_appearance < num_visuals and len(conv_text) > 0: + filtered_data.append(item) + elif num_img_token_appearance > num_visuals: + item["num_img_token_appearance"] = num_img_token_appearance + item["num_visuals"] = num_visuals + mismatch_data.append(item) + + if not mismatch_flag: + print(f"Data mismatch for {item}") + + mismatch_flag = True + except Exception as e: + print(f"Error: {e}") + print() + + if mismatch_flag: + print(f"Data mismatch for {dd_json_path}") + + if len(filtered_data) < len(data): + saving_dd_json_path = dd_json_path.replace(".jsonl", f"fltd_{len(filtered_data)}.json").replace(".json", f"fltd_{len(filtered_data)}.json") + with open(saving_dd_json_path, "w") as f: + json.dump(filtered_data, f, indent=2) + print(f"Filtered data count: {len(filtered_data)}") + else: + pass + + def stat_and_filter_data(self, threshold): + if isinstance(self.data, dict): + cur_lens_list = [] + single_image_count = 0 + multiple_image_count = 0 + video_count = 0 + total_count = 0 + text_count = 0 + + for d in self.data["datasets"]: + dd_json_path = d["json_path"] + data = self.load_json_data(dd_json_path) + sampling_strategy = d["sampling_strategy"] + filtered_data = [] + + try: + if sampling_strategy != "all": + percentage = float(sampling_strategy.split(":")[-1].replace("%", "")) / 100.0 + else: + percentage = 1.0 + except Exception as e: + print(f"Error parsing sampling strategy: {e}") + percentage = 1.0 + + sampled_count = int(len(data) * percentage) + print(f"{dd_json_path}: {sampled_count} (sampled from {len(data)})") + + save_flag = False + for item in data: + total_count += 1 + conversations = item["conversations"] + filtered_conversations = [] + current_token_count = 0 + + for i in range(0, len(conversations), 2): + if i + 1 < len(conversations): + human_conv = conversations[i] + gpt_conv = conversations[i + 1] + pair_tokens = len(human_conv["value"].split()) + len(gpt_conv["value"].split()) + + if current_token_count + pair_tokens <= threshold: + filtered_conversations.extend([human_conv, gpt_conv]) + current_token_count += pair_tokens + else: + save_flag = True + break + + if filtered_conversations: + item["conversations"] = filtered_conversations + cur_len = sum([len(conv["value"].split()) for conv in filtered_conversations]) + cur_lens_list.append(cur_len) + filtered_data.append(item) + + if "image" in item: + if isinstance(item["image"], list): + if len(item["image"]) > 1: + multiple_image_count += 1 + else: + single_image_count += 1 + else: + single_image_count += 1 + elif "video" in item: + video_count += 1 + else: + text_count += 1 + + # Save filtered data for each dataset + if filtered_data and save_flag: + if dd_json_path.endswith(".jsonl"): + output_file = dd_json_path.replace(".jsonl", f"_filtered_{threshold}tokens_{len(filtered_data)}.jsonl") + with open(output_file, "w") as f: + for item in filtered_data: + f.write(json.dumps(item) + "\n") + else: + output_file = dd_json_path.replace(".json", f"_filtered_{threshold}tokens_{len(filtered_data)}.json") + with open(output_file, "w") as f: + json.dump(filtered_data, f, indent=2) + print(f"Filtered data for {dd_json_path} saved to: {output_file}") + + print(f"Max length: {max(cur_lens_list)}, Min length: {min(cur_lens_list)}, Average length: {sum(cur_lens_list) / len(cur_lens_list)}") + print(f"Total items: {total_count}") + print(f"Text items: {text_count} ({text_count/total_count*100:.2f}%)") + print(f"Single image items: {single_image_count} ({single_image_count/total_count*100:.2f}%)") + print(f"Multiple image items: {multiple_image_count} ({multiple_image_count/total_count*100:.2f}%)") + print(f"Video items: {video_count} ({video_count/total_count*100:.2f}%)") + + +def main(file_path, image_root, operation, video_root, threshold=None): + processor = DataProcessor(file_path, image_root, video_root) + if operation == "check": + processor.process_images() + elif operation == "count": + total_items = processor.count_items() + print(f"Total items: {total_items}") + elif operation == "filter": + processor.filter_data() + elif operation == "stat": + processor.stat_data() + elif operation == "stat_and_filter": + if threshold is None: + raise ValueError("Threshold must be provided for stat_and_filter operation") + processor.stat_and_filter_data(threshold) + else: + raise ValueError("Unsupported operation") + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--file_path", type=str, default="/mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next/scripts/i18n/scale_llms/next_continual.yaml") + parser.add_argument("--image_root", type=str, default="/mnt/bn/vl-research/data/llava_data") + parser.add_argument("--video_root", type=str, default="/mnt/bn/vl-research/data/llava_video") + parser.add_argument("--operation", type=str, default="filter") + parser.add_argument("--threshold", type=int, default=None, help="Threshold for stat_and_filter operation") + args = parser.parse_args() + main(args.file_path, args.image_root, args.operation, args.video_root, args.threshold) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/demo/video_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/demo/video_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..d93f6582699d63b65b1b41fabb39a59a7e71addd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/demo/video_demo.py @@ -0,0 +1,335 @@ +import argparse +import torch + +from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN +from llava.conversation import conv_templates, SeparatorStyle +from llava.model.builder import load_pretrained_model +from llava.utils import disable_torch_init +from llava.mm_utils import process_anyres_image,tokenizer_image_token, get_model_name_from_path, KeywordsStoppingCriteria + +import json +import os +import math +from tqdm import tqdm +from decord import VideoReader, cpu + +from transformers import AutoConfig + +import cv2 +import base64 +import openai + +from PIL import Image + + + +import numpy as np + +def split_list(lst, n): + """Split a list into n (roughly) equal-sized chunks""" + chunk_size = math.ceil(len(lst) / n) # integer division + return [lst[i : i + chunk_size] for i in range(0, len(lst), chunk_size)] + + +def get_chunk(lst, n, k): + chunks = split_list(lst, n) + return chunks[k] + + +def parse_args(): + """ + Parse command-line arguments. + """ + parser = argparse.ArgumentParser() + + # Define the command-line arguments + parser.add_argument("--video_path", help="Path to the video files.", required=True) + parser.add_argument("--output_dir", help="Directory to save the model results JSON.", required=True) + parser.add_argument("--output_name", help="Name of the file for storing results JSON.", required=True) + parser.add_argument("--model-path", type=str, default="facebook/opt-350m") + parser.add_argument("--model-base", type=str, default=None) + parser.add_argument("--conv-mode", type=str, default=None) + parser.add_argument("--chunk-idx", type=int, default=0) + parser.add_argument("--mm_resampler_type", type=str, default="spatial_pool") + parser.add_argument("--mm_spatial_pool_stride", type=int, default=4) + parser.add_argument("--mm_spatial_pool_out_channels", type=int, default=1024) + parser.add_argument("--mm_spatial_pool_mode", type=str, default="average") + parser.add_argument("--image_aspect_ratio", type=str, default="anyres") + parser.add_argument("--image_grid_pinpoints", type=str, default="[(224, 448), (224, 672), (224, 896), (448, 448), (448, 224), (672, 224), (896, 224)]") + parser.add_argument("--mm_patch_merge_type", type=str, default="spatial_unpad") + parser.add_argument("--overwrite", type=lambda x: (str(x).lower() == 'true'), default=True) + parser.add_argument("--for_get_frames_num", type=int, default=4) + parser.add_argument("--load_8bit", type=lambda x: (str(x).lower() == 'true'), default=False) + parser.add_argument("--prompt", type=str, default=None) + parser.add_argument("--api_key", type=str, help="OpenAI API key") + parser.add_argument("--mm_newline_position", type=str, default="no_token") + parser.add_argument("--force_sample", type=lambda x: (str(x).lower() == 'true'), default=False) + parser.add_argument("--add_time_instruction", type=str, default=False) + return parser.parse_args() + +def load_video(video_path,args): + if args.for_get_frames_num == 0: + return np.zeros((1, 336, 336, 3)) + vr = VideoReader(video_path, ctx=cpu(0),num_threads=1) + total_frame_num = len(vr) + video_time = total_frame_num / vr.get_avg_fps() + fps = round(vr.get_avg_fps()) + frame_idx = [i for i in range(0, len(vr), fps)] + frame_time = [i/fps for i in frame_idx] + if len(frame_idx) > args.for_get_frames_num or args.force_sample: + sample_fps = args.for_get_frames_num + uniform_sampled_frames = np.linspace(0, total_frame_num - 1, sample_fps, dtype=int) + frame_idx = uniform_sampled_frames.tolist() + frame_time = [i/vr.get_avg_fps() for i in frame_idx] + frame_time = ",".join([f"{i:.2f}s" for i in frame_time]) + spare_frames = vr.get_batch(frame_idx).asnumpy() + # import pdb;pdb.set_trace() + + return spare_frames,frame_time,video_time + + + + +def load_video_base64(path): + video = cv2.VideoCapture(path) + + base64Frames = [] + while video.isOpened(): + success, frame = video.read() + if not success: + break + _, buffer = cv2.imencode(".jpg", frame) + base64Frames.append(base64.b64encode(buffer).decode("utf-8")) + + video.release() + # print(len(base64Frames), "frames read.") + return base64Frames + + +def run_inference(args): + """ + Run inference on ActivityNet QA DataSet using the Video-ChatGPT model. + + Args: + args: Command-line arguments. + """ + # Initialize the model + if "gpt4v" != args.model_path: + model_name = get_model_name_from_path(args.model_path) + # Set model configuration parameters if they exist + if args.overwrite == True: + overwrite_config = {} + overwrite_config["mm_spatial_pool_mode"] = args.mm_spatial_pool_mode + overwrite_config["mm_spatial_pool_stride"] = args.mm_spatial_pool_stride + overwrite_config["mm_newline_position"] = args.mm_newline_position + + cfg_pretrained = AutoConfig.from_pretrained(args.model_path) + + # import pdb;pdb.set_trace() + if "qwen" not in args.model_path.lower(): + if "224" in cfg_pretrained.mm_vision_tower: + # suppose the length of text tokens is around 1000, from bo's report + least_token_number = args.for_get_frames_num*(16//args.mm_spatial_pool_stride)**2 + 1000 + else: + least_token_number = args.for_get_frames_num*(24//args.mm_spatial_pool_stride)**2 + 1000 + + scaling_factor = math.ceil(least_token_number/4096) + if scaling_factor >= 2: + if "vicuna" in cfg_pretrained._name_or_path.lower(): + print(float(scaling_factor)) + overwrite_config["rope_scaling"] = {"factor": float(scaling_factor), "type": "linear"} + overwrite_config["max_sequence_length"] = 4096 * scaling_factor + overwrite_config["tokenizer_model_max_length"] = 4096 * scaling_factor + + tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name, load_8bit=args.load_8bit, overwrite_config=overwrite_config) + else: + tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name) + else: + pass + + # import pdb;pdb.set_trace() + if getattr(model.config, "force_sample", None) is not None: + args.force_sample = model.config.force_sample + else: + args.force_sample = False + + # import pdb;pdb.set_trace() + + if getattr(model.config, "add_time_instruction", None) is not None: + args.add_time_instruction = model.config.add_time_instruction + else: + args.add_time_instruction = False + + # Create the output directory if it doesn't exist + if not os.path.exists(args.output_dir): + os.makedirs(args.output_dir) + + output_name = args.output_name + answers_file = os.path.join(args.output_dir, f"{output_name}.json") + ans_file = open(answers_file, "w") + + video_path = args.video_path + + all_video_pathes = [] + + # Check if the video_path is a directory or a file + if os.path.isdir(video_path): + # If it's a directory, loop over all files in the directory + for filename in os.listdir(video_path): + # Load the video file + cur_video_path = os.path.join(video_path, f"{filename}") + all_video_pathes.append(os.path.join(video_path, cur_video_path)) + else: + # If it's a file, just process the video + all_video_pathes.append(video_path) + + # import pdb;pdb.set_trace() + for video_path in all_video_pathes: + + sample_set = {} + question = args.prompt + sample_set["Q"] = question + sample_set["video_name"] = video_path + + + # Check if the video exists + if os.path.exists(video_path): + if "gpt4v" != args.model_path: + video,frame_time,video_time = load_video(video_path, args) + video = image_processor.preprocess(video, return_tensors="pt")["pixel_values"].half().cuda() + video = [video] + else: + spare_frames,frame_time,video_time = load_video_base64(video_path) + interval = int(len(video) / args.for_get_frames_num) + + # try: + # Run inference on the video and add the output to the list + if "gpt4v" != args.model_path: + qs = question + if args.add_time_instruction: + time_instruciton = f"The video lasts for {video_time:.2f} seconds, and {len(video[0])} frames are uniformly sampled from it. These frames are located at {frame_time}.Please answer the following questions related to this video." + qs = f'{time_instruciton}\n{qs}' + if model.config.mm_use_im_start_end: + qs = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + "\n" + qs + else: + qs = DEFAULT_IMAGE_TOKEN + "\n" + qs + + conv = conv_templates[args.conv_mode].copy() + conv.append_message(conv.roles[0], qs) + conv.append_message(conv.roles[1], None) + prompt = conv.get_prompt() + + input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt").unsqueeze(0).cuda() + if tokenizer.pad_token_id is None: + if "qwen" in tokenizer.name_or_path.lower(): + print("Setting pad token to bos token for qwen model.") + tokenizer.pad_token_id = 151643 + + attention_masks = input_ids.ne(tokenizer.pad_token_id).long().cuda() + + stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2 + keywords = [stop_str] + stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids) + + cur_prompt = question + else: + prompt = question + + system_error = "" + + if "gpt4v" != args.model_path: + + + with torch.inference_mode(): + # model.update_prompt([[cur_prompt]]) + # import pdb;pdb.set_trace() + # output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=True, temperature=0.2, max_new_tokens=1024, use_cache=True, stopping_criteria=[stopping_criteria]) + if "mistral" not in cfg_pretrained._name_or_path.lower(): + output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=False, temperature=0.0, max_new_tokens=1024, top_p=0.1,num_beams=1,use_cache=True, stopping_criteria=[stopping_criteria]) + # output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=True, temperature=0.2, max_new_tokens=1024, use_cache=True, stopping_criteria=[stopping_criteria]) + else: + output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=False, temperature=0.0, max_new_tokens=1024, top_p=0.1, num_beams=1, use_cache=True) + # output_ids = model.generate(inputs=input_ids, images=video, attention_mask=attention_masks, modalities="video", do_sample=True, temperature=0.2, max_new_tokens=1024, use_cache=True) + else: + openai.api_key = args.api_key # Your API key here + + max_num_retries = 0 + retry = 5 + PROMPT_MESSAGES = [ + { + "role": "user", + "content": [ + f"These are frames from a video that I want to upload. Answer me one question of this video: {prompt}", + *map(lambda x: {"image": x, "resize": 336}, video[0::interval]), + ], + }, + ] + params = { + "model": "gpt-4-vision-preview", #gpt-4-1106-vision-preview + "messages": PROMPT_MESSAGES, + "max_tokens": 1024, + } + sucess_flag=False + while max_num_retries < retry: + try: + result = openai.ChatCompletion.create(**params) + outputs = result.choices[0].message.content + sucess_flag = True + break + except Exception as inst : + if 'error' in dir(inst): + # import pdb;pdb.set_trace() + if inst.error.code == 'rate_limit_exceeded': + if "TPM" in inst.error.message: + time.sleep(30) + continue + else: + import pdb;pdb.set_trace() + elif inst.error.code == 'insufficient_quota': + print(f'insufficient_quota key') + exit() + elif inst.error.code == 'content_policy_violation': + print(f'content_policy_violation') + system_error = "content_policy_violation" + + break + print('Find error message in response: ',str(inst.error.message), 'error code: ', str(inst.error.code)) + + continue + if not sucess_flag: + print(f'Calling OpenAI failed after retrying for {max_num_retries} times. Check the logs for details.') + exit() + + if "gpt4v" != args.model_path: + outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip() + else: + print(len(video[0::interval])) + + print(f"Question: {prompt}\n") + print(f"Response: {outputs}\n") + + if "gpt4v" == args.model_path: + if system_error == 'content_policy_violation': + continue + elif system_error == "": + continue + else: + import pdb;pdb.set_trace() + + # import pdb;pdb.set_trace() + if "mistral" not in cfg_pretrained._name_or_path.lower(): + if outputs.endswith(stop_str): + outputs = outputs[: -len(stop_str)] + + outputs = outputs.strip() + + sample_set["pred"] = outputs + ans_file.write(json.dumps(sample_set, ensure_ascii=False) + "\n") + ans_file.flush() + + ans_file.close() + + +if __name__ == "__main__": + args = parse_args() + run_inference(args) \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/equal_splitter.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/equal_splitter.py new file mode 100644 index 0000000000000000000000000000000000000000..8f89f2d2d984b7b58010daecb036dc55472d735f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/equal_splitter.py @@ -0,0 +1,38 @@ +import json +from math import ceil + + +def split_json_file(input_file, n_splits): + # Read the JSON file + with open(input_file, "r") as file: + data = json.load(file) + + # Calculate the size of each split + total_items = len(data) + items_per_split = ceil(total_items / n_splits) + + # Split the data and save into separate files + for i in range(n_splits): + start_index = i * items_per_split + end_index = min((i + 1) * items_per_split, total_items) + split_data = data[start_index:end_index] + + # Write the split data to a new JSON file + with open(f"{input_file.split('.')[0]}_split_{i}.json", "w") as split_file: + json.dump(split_data, split_file, indent=4) + + +def main(): + import argparse + + parser = argparse.ArgumentParser(description="Split a JSON file into multiple parts.") + parser.add_argument("--input_file", type=str, help="The JSON file to split") + parser.add_argument("--n_splits", type=int, help="The number of splits") + + args = parser.parse_args() + + split_json_file(args.input_file, args.n_splits) + + +if __name__ == "__main__": + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/remove_mid_ckpt.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/remove_mid_ckpt.py new file mode 100644 index 0000000000000000000000000000000000000000..612b717d620f087f0708909678d96f4496157562 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/remove_mid_ckpt.py @@ -0,0 +1,35 @@ +import os +import shutil +import glob + + +def remove_checkpoints(directory, pattern): + # Walk through the directory + for root, dirs, files in os.walk(directory): + # Use glob to find paths matching the pattern + for file_path in glob.glob(os.path.join(root, pattern)): + # Check if it is a directory + if "llava-1.6-mistral-7b" in file_path: + continue + if os.path.isdir(file_path): + # Remove the directory + print(f"Removing {file_path}") + input("Press Enter to continue...") + shutil.rmtree(file_path) + print(f"Removed directory: {file_path}") + else: + print(f"Removing {file_path}") + input("Press Enter to continue...") + # Remove the file + os.remove(file_path) + print(f"Removed file: {file_path}") + + +# Directory containing the checkpoints +directory = "/mnt/bn/vl-research/checkpoints/feng/" + +# Pattern to match in the file names +pattern = "global_step*" + +# Call the function +remove_checkpoints(directory, pattern) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/sgl_llava_inference_multinode.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/sgl_llava_inference_multinode.py new file mode 100644 index 0000000000000000000000000000000000000000..869099d734bfd9fb09fbe64a278f0ef80b612cfb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/sgl_llava_inference_multinode.py @@ -0,0 +1,125 @@ +import argparse +import json +import time +import os +import tqdm +import sglang as sgl +from sglang.test.test_utils import select_sglang_backend +from sglang.utils import dump_state_text + + +@sgl.function +def image_description(s, image_file): + prompt = "Please generate detailed descriptions of the given image." + s += sgl.user(sgl.image(image_file) + prompt) + s += sgl.assistant(sgl.gen("answer", max_tokens=1024, temperature=0.0)) + + +def load_progress(progress_file): + print(f"Load progress from {progress_file}") + if os.path.exists(progress_file): + with open(progress_file, "r") as f: + return json.load(f) + return {"last_index": -1, "last_chunk": -1, "results": [], "annotations": []} + + +def save_progress(progress_file, progress_data): + with open(progress_file, "w") as f: + json.dump(progress_data, f, indent=2) + + +def find_images_in_subfolders(folder_path): + image_extensions = (".png", ".jpg", ".jpeg", ".gif", ".bmp") + image_files = [] + for root, dirs, files in os.walk(folder_path): + for file in files: + if file.endswith(image_extensions): + image_files.append(os.path.join(root, file)) + return image_files + + +def main(args): + dist_rank = args.dist + dist_size = args.total_dist + + base_dir = os.path.dirname(args.result_file) + os.makedirs(base_dir, exist_ok=True) # Ensure the base directory exists + progress_file = f"{base_dir}/progress_{dist_rank}_or_{dist_size}.json" + progress_data = load_progress(progress_file) + + with open(args.json_path, "r") as fp: + data = json.load(fp) + + image_files = [os.path.join(args.images_root, item["image"]) for item in data] + image_files = image_files[: args.limit] if args.limit > 0 else image_files + + # Shard the data + shard_size = len(image_files) // dist_size + start_index = shard_size * dist_rank + end_index = start_index + shard_size if dist_rank < dist_size - 1 else len(image_files) + shard_files = image_files[start_index:end_index] + + print(f"Querying {len(shard_files)} images from index {start_index} to {end_index - 1}") + + # Select backend + backend = select_sglang_backend(args) + sgl.set_default_backend(backend) + + tic = time.time() + batch_size = args.parallel + for batch_start in tqdm.tqdm(range(0, len(shard_files), batch_size)): + batch_end = min(batch_start + batch_size, len(shard_files)) + if batch_start <= progress_data.get("last_index", -1): + print(f"Skipping already processed batch starting at {batch_start}") + continue + batch_arguments = [{"image_file": image_file} for image_file in shard_files[batch_start:batch_end]] + try: + batch_states = image_description.run_batch(batch_arguments, temperature=0, num_threads=args.parallel, progress_bar=False) + for i, ret in enumerate(batch_states): + image_file = batch_arguments[i]["image_file"] + caption = ret.text().split("ASSISTANT:")[-1].strip() + progress_data["annotations"].append({"image_file": image_file, "caption": caption}) + progress_data["last_index"] = batch_start + i # Update last_index relative to this rank's shard + + save_progress(progress_file, progress_data) + except Exception as e: + print(f"Error during batch processing: {e}") + save_progress(progress_file, progress_data) + break + + latency = time.time() - tic + print(f"Latency: {latency:.3f}") + + value = { + "task": "image_captioning", + "backend": args.backend, + "num_gpus": 1, + "latency": round(latency, 3), + "num_requests": len(shard_files), + "parallel": args.parallel, + "results": progress_data["annotations"], + } + + result_file = args.result_file.replace(".json", f"_shard_{dist_rank}_or_{dist_size}.json") + print(f"Write output to {result_file}") + with open(result_file, "w") as fout: + json.dump(value, fout, indent=2) + + save_progress(progress_file, progress_data) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--images_root", type=str, default="/mnt/bn/vl-research/data/llava_data/cc3m") + parser.add_argument("--json_path", type=str, default="/mnt/bn/vl-research/data/llava_instruct/cc3m_recap_requery_363707.json") + parser.add_argument("--max_tokens", type=int, default=1024) + parser.add_argument("--parallel", type=int, default=32) + parser.add_argument("--backend", type=str, default="srt") + parser.add_argument("--host", type=str, default="http://127.0.0.1") + parser.add_argument("--port", type=int, default=30000) + parser.add_argument("--result_file", type=str, default="/mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next/playground/sgl_llava_inference.json") + parser.add_argument("--limit", type=int, default=-1) + parser.add_argument("--dist", type=int, default=0, help="The rank of the distributed machine") + parser.add_argument("--total_dist", type=int, default=6, help="Total number of distributed machines") + args = parser.parse_args() + main(args) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/upload_data.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/upload_data.py new file mode 100644 index 0000000000000000000000000000000000000000..d1acf2ba420c3418098b8a2ed67555a306c4cc9d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/playground/upload_data.py @@ -0,0 +1,217 @@ +from datasets import Dataset, Features, Value, ClassLabel, Sequence, Image +import json +import PIL.Image as pil_image +from io import BytesIO +from tqdm import tqdm + +json_paths = [ + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_metagen_87358.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_rule_geo_100000.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/k12_printing_train_256646.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/iiit5k_annotations_2000.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/hme100k_train_clean_74502.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_azuregpt_detailed_understanding_4874.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_vqa_4404.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_azuregpt4v_1992.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_chart_1787.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_normal_gpt4v_filtered_10500.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/scienceqa_nona_context_19218.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_vflan4v_20000.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_laion4v_50000.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textocr_gpt4v_train_converted_25114.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_train_internvl_single_12413.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textcaps_train_21952.json", + # "/mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_qa_sft.json", + # "/mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_cap_sft.json", + # "/mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_ie_sft.json", + # "/mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_kg_sft.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/vision_flan_filtered_186070.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mathqa_29837.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo3k_2101.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_qa_converted_67833.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_align_converted_60252.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-coco-50k.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-knowledge-2k.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-llava-30k.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-sam-20k.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_CLEVR-Math_5290.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_FigureQA_17597.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Geometry3K_9734.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GeoQA+_17172.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GEOS_508.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_IconQA_22599.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_MapQA_5235.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_PMC-VQA_35958.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Super-CLEVR_8652.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TabMWP_22462.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_UniGeo_11959.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VizWiz_6614.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_qwen2_72b_st_300000_sp_token_fltd_299992.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_st_300000.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_mt_300000_sp_token_fltd_299998.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/image_textualization_dataset_filtered.json", + # "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/cambrian_filtered_gpt4vo_sp_token_fltd_max10k.json", + "/mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4o_dataset.jsonl", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/ai2d_llava_format_2434.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/aokvqa_16539_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/chart2text_26961.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/chartqa_18265_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/clevr_70000_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/diagram_image_to_text_300.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/dvqa_200000_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/figureqa_100000_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/geomverse_9303.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/hateful_memes_8500_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/hitab_2500_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/iam_5663.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/raven_42000.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/iconqa_llava_format_27307.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/infographic_vqa_2118_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/intergps_1280_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/mapqa_37417_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/multihiertt_7619.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/rendered_text_10000.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/robut_sqa_8514.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wikisql_74989.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wtq_38246_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/screen2words_15730.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/scienceqa_llava_format_4976.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/tabmwp_22722.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/tallyqa_98680_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/st_vqa_17247_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/tqa_llava_format_27307.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/visual7w_llava_format_14366.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/visualmrc_3027.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/vqarad_313_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/vsr_2157_llava_format.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/vistext_9969.json", + "/mnt/bn/vl-research/data/llava_instruct/cauldron/websight_10000.json" +] + +short_names = [ + # "mavis_math_metagen", + # "mavis_math_rule_geo", + # "k12_printing", + # "iiit5k", + # "hme100k", + # "ai2d(gpt4v)", + # "infographic_vqa", + # "infographic(gpt4v)", + # "lrv_chart", + # "lrv_normal(filtered)", + # "scienceqa(nona_context)", + # "allava_instruct_vflan4v", + # "allava_instruct_laion4v", + # "textocr(gpt4v)", + # "ai2d(internvl)", + # "textcaps", + # "ureader_qa", # need to re-upload + # "ureader_cap", # need to re-upload + # "ureader_ie", # need to re-upload + # "ureader_kg", # need to re-upload + # "vision_flan(filtered)", + # "mathqa", + # "geo3k", + # "geo170k(qa)", + # "geo170k(align)", + # "sharegpt4v(coco)", + # "sharegpt4v(knowledge)", + # "sharegpt4v(llava)", + # "sharegpt4v(sam)", + # "CLEVR-Math(MathV360K)", + # "FigureQA(MathV360K)", + # "Geometry3K(MathV360K)", + # "GeoQA+(MathV360K)", + # "GEOS(MathV360K)", + # "IconQA(MathV360K)", + # "MapQA(MathV360K)", + # "PMC-VQA(MathV360K)", + # "Super-CLEVR(MathV360K)", + # "TabMWP(MathV360K)", + # "UniGeo(MathV360K)", + # "VizWiz(MathV360K)", + # "magpie_pro(qwen2_72b_st)", + # "magpie_pro(l3_80b_st)", + # "magpie_pro(l3_80b_mt)", + # "image_textualization(filtered)", + # "cambrian(filtered_gpt4vo)", # need to re-upload + "sharegpt4o", + "ai2d(cauldron,llava_format)", + "aokvqa(cauldron,llava_format)", + "chart2text(cauldron)", + "chartqa(cauldron,llava_format)", + "clevr(cauldron,llava_format)", + "diagram_image_to_text(cauldron)", + "dvqa(cauldron,llava_format)", + "figureqa(cauldron,llava_format)", + "geomverse(cauldron)", + "hateful_memes(cauldron,llava_format)", + "hitab(cauldron,llava_format)", + "iam(cauldron)", + "raven(cauldron)", + "iconqa(cauldron,llava_format)", + "infographic_vqa_llava_format", + "intergps(cauldron,llava_format)", + "mapqa(cauldron,llava_format)", + "multihiertt(cauldron)", + "rendered_text(cauldron)", + "robut_sqa(cauldron)", + "robut_wikisql(cauldron)", + "robut_wtq(cauldron,llava_format)", + "screen2words(cauldron)", + "scienceqa(cauldron,llava_format)", + "tabmwp(cauldron)", + "tallyqa(cauldron,llava_format)", + "st_vqa(cauldron,llava_format)", + "tqa(cauldron,llava_format)", + "visual7w(cauldron,llava_format)", + "visualmrc(cauldron)", + "vqarad(cauldron,llava_format)", + "vsr(cauldron,llava_format)", + "vistext(cauldron)", + "websight(cauldron)" +] + +def upload_data(json_path, short_name): + def gen(): + if json_path.endswith(".jsonl"): + with open(json_path, "r") as f: + data = [json.loads(line) for line in f] + else: + with open(json_path, "r") as f: + data = json.load(f) + + preview_index = 5 + idx = 0 + for item in tqdm(data): + if preview_index > 0: + preview_index -= 1 + print(item) + continue + + try: + if "image" in item: + image_path = f"/mnt/bn/vl-research/data/llava_data/{item['image']}" + try: + with open(image_path, "rb") as img_file: + image = pil_image.open(BytesIO(img_file.read())) + except: + print(f"Failed to load image {item['image']}") + continue + else: + image = None + + item_id = item["id"] if "id" in item else f"{idx:06d}" + yield {"id": item_id, "image": image, "conversations": item["conversations"], "data_source": short_name} + idx += 1 + + except Exception as e: + print(e) + continue + + + hf_dataset = Dataset.from_generator(generator=gen, num_proc=32) + hf_dataset.push_to_hub("lmms-lab/LLaVA-OneVision-Data", config_name=short_name, split="train") + +for json_path, short_name in zip(json_paths, short_names): + upload_data(json_path, short_name) \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/pyproject.toml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..4e189f5a128e771dd44e5dfcc5d113c901016155 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/pyproject.toml @@ -0,0 +1,74 @@ +[tool.black] +line-length = 240 + +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "llava" +version = "1.7.0.dev0" +description = "LLaVA OneVision: The Next Generation of LLaVA with Better Image and Video Understanding Capabilities" +readme = "README.md" +requires-python = ">=3.8" +classifiers = [ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: Apache Software License", +] + +[project.optional-dependencies] +standalone = [ + "shortuuid", + "httpx==0.24.0", + "einops", + "ftfy", +] + + +train = [ + "llava[standalone]", + "deepspeed==0.14.4", + "bitsandbytes==0.41.0", + "gradio_client", + "hf_transfer", + "tyro", +] + +[project.urls] +"Homepage" = "https://llava-vl.github.io" +"Bug Tracker" = "https://github.com/haotian-liu/LLaVA/issues" + +[tool.setuptools.packages.find] +include = ["llava*", "trl*"] +exclude = [ + "assets*", + "benchmark*", + "docs", + "dist*", + "playground*", + "scripts*", + "tests*", + "checkpoints*", + "project_checkpoints*", + "debug_checkpoints*", + "mlx_configs*", + "wandb*", + "notebooks*", +] + +[tool.wheel] +exclude = [ + "assets*", + "benchmark*", + "docs", + "dist*", + "playground*", + "scripts*", + "tests*", + "checkpoints*", + "project_checkpoints*", + "debug_checkpoints*", + "mlx_configs*", + "wandb*", + "notebooks*", +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/requirements.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..66ea557efca57c3784eac2042588240529a81003 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/requirements.txt @@ -0,0 +1,324 @@ +Babel==2.14.0 +DataProperty==1.0.1 +Deprecated==1.2.14 +GitPython==3.1.43 +Jinja2==3.1.3 +Levenshtein==0.25.1 +MarkupSafe==2.1.5 +PyJWT==2.8.0 +PyYAML==6.0.1 +Pygments==2.17.2 +QtPy==2.4.1 +Send2Trash==1.8.3 +absl-py==2.1.0 +accelerate==0.29.3 +aiofiles==22.1.0 +aiohttp==3.9.5 +aiosignal==1.3.1 +aiosqlite==0.20.0 +altair==5.3.0 +anyio==4.3.0 +appdirs==1.4.4 +argon2-cffi-bindings==21.2.0 +argon2-cffi==23.1.0 +arrow==1.3.0 +asttokens==2.4.1 +async-timeout==4.0.3 +attrs==23.1.0 +beautifulsoup4==4.12.3 +bidict==0.23.1 +bitsandbytes==0.41.0 +black==24.1.0 +bleach==6.1.0 +byted-remote-ikernel==0.4.8 +byted-torch-monitor==0.0.1 +byted-wandb==0.13.72 +bytedance-context==0.7.1 +bytedance-metrics==0.5.1 +bytedance.modelhub==0.0.64 +bytedance.servicediscovery==0.1.2 +bytedbackgrounds==0.0.6 +byteddatabus==1.0.6 +byteddps==0.1.2 +bytedenv==0.6.2 +bytedlogger==0.15.1 +bytedmemfd==0.2 +bytedmetrics==0.10.2 +bytedpymongo==2.0.5 +bytedrh2==1.18.7a2 +bytedservicediscovery==0.17.4 +bytedtcc==1.4.2 +bytedtos==1.1.16 +bytedtrace==0.3.0 +bytedztijwthelper==0.0.22 +bytedztispiffe==0.0.11 +certifi==2024.2.2 +cffi==1.16.0 +cfgv==3.4.0 +chardet==5.2.0 +charset-normalizer==3.3.2 +click==8.1.7 +colorama==0.4.6 +comm==0.2.2 +contourpy==1.2.1 +crcmod==1.7 +cryptography==38.0.4 +cycler==0.12.1 +datasets==2.16.1 +debugpy==1.8.1 +decorator==5.1.1 +decord==0.6.0 +deepspeed==0.12.2 +defusedxml==0.7.1 +dill==0.3.7 +distlib==0.3.8 +distro==1.9.0 +dnspython==2.6.1 +docker-pycreds==0.4.0 +docstring_parser==0.16 +einops-exts==0.0.4 +einops==0.6.1 +entrypoints==0.4 +et-xmlfile==1.1.0 +eval_type_backport==0.2.0 +evaluate==0.4.1 +exceptiongroup==1.2.1 +executing==2.0.1 +fastapi==0.110.2 +fastjsonschema==2.19.1 +ffmpy==0.3.2 +filelock==3.13.4 +flash-attn==2.5.7 +fonttools==4.51.0 +fqdn==1.5.1 +frozenlist==1.4.1 +fsspec==2023.10.0 +ftfy==6.2.0 +gitdb==4.0.11 +gradio==3.35.2 +gradio_client==0.2.9 +grpcio==1.62.2 +h11==0.14.0 +hf_transfer==0.1.6 +hjson==3.1.0 +httpcore==0.17.3 +httpx==0.24.0 +huggingface-hub==0.22.2 +identify==2.5.36 +idna==3.7 +importlib_metadata==7.1.0 +importlib_resources==6.4.0 +iniconfig==2.0.0 +ipaddress==1.0.23 +ipykernel==6.29.4 +ipython-genutils==0.2.0 +ipython==8.18.1 +ipywidgets==8.1.2 +isoduration==20.11.0 +jedi==0.19.1 +joblib==1.4.0 +json5==0.9.25 +jsonlines==4.0.0 +jsonpointer==2.4 +jsonschema-specifications==2023.12.1 +jsonschema==4.21.1 +jupyter-client==7.0.0 +jupyter-console==6.6.3 +jupyter-events==0.10.0 +jupyter-ydoc==0.2.5 +jupyter==1.0.0 +jupyter_core==5.7.2 +jupyter_server==2.14.0 +jupyter_server_fileid==0.9.2 +jupyter_server_terminals==0.5.3 +jupyter_server_ydoc==0.8.0 +jupyterlab==3.6.4 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.27.1 +jupyterlab_widgets==3.0.10 +kiwisolver==1.4.5 +linkify-it-py==2.0.3 +llava==1.7.0.dev0 +llava==1.7.0.dev0 +lmms_eval==0.1.1 +lxml==5.2.1 +markdown-it-py==2.2.0 +markdown2==2.4.13 +matplotlib-inline==0.1.7 +matplotlib==3.8.4 +mbstrdecoder==1.1.3 +mdit-py-plugins==0.3.3 +mdurl==0.1.2 +mistune==3.0.2 +mpmath==1.3.0 +msgpack==1.0.8 +multidict==6.0.5 +multiprocess==0.70.15 +mypy-extensions==1.0.0 +nbclassic==1.0.0 +nbclient==0.10.0 +nbconvert==7.16.3 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.2.1 +ninja==1.11.1.1 +nltk==3.8.1 +nodeenv==1.8.0 +notebook==6.5.6 +notebook_shim==0.2.4 +numexpr==2.10.0 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.18.1 +nvidia-nvjitlink-cu12==12.4.127 +nvidia-nvtx-cu12==12.1.105 +open-clip-torch==2.24.0 +openai==1.23.6 +opencv-python-headless==4.9.0.80 +openpyxl==3.1.2 +orjson==3.10.1 +overrides==7.7.0 +packaging==24.0 +pandas==2.2.2 +pandocfilters==1.5.1 +parso==0.8.4 +pathlib2==2.3.7.post1 +pathspec==0.12.1 +pathtools==0.1.2 +pathvalidate==3.2.0 +peft==0.4.0 +pexpect==4.8.0 +pillow==10.3.0 +pip==23.3.1 +pip==24.0 +platformdirs==4.2.1 +pluggy==1.5.0 +ply==3.11 +portalocker==2.8.2 +pre-commit==3.7.0 +prometheus_client==0.20.0 +promise==2.3 +prompt-toolkit==3.0.43 +protobuf==3.20.3 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +py-cpuinfo==9.0.0 +py-spy==0.3.14 +py==1.11.0 +pyOpenSSL==22.1.0 +pyarrow-hotfix==0.6 +pyarrow==16.0.0 +pybind11==2.12.0 +pycocoevalcap==1.2 +pycocotools==2.0.7 +pycparser==2.22 +pycryptodomex==3.20.0 +pydantic==1.10.8 +pydub==0.25.1 +pynvml==11.5.0 +pyparsing==3.1.2 +pytablewriter==1.2.0 +pytest==6.2.5 +python-consul==1.1.0 +python-dateutil==2.9.0.post0 +python-engineio==4.9.0 +python-etcd==0.4.5 +python-json-logger==2.0.7 +python-multipart==0.0.9 +python-socketio==5.11.2 +pytz==2024.1 +pyzmq==24.0.1 +qtconsole==5.5.1 +rapidfuzz==3.8.1 +referencing==0.35.0 +regex==2024.4.16 +requests==2.31.0 +responses==0.18.0 +rfc3339-validator==0.1.4 +rfc3986-validator==0.1.1 +rich==13.7.1 +rouge-score==0.1.2 +rpds-py==0.18.0 +sacrebleu==2.4.2 +safetensors==0.4.3 +schedule==1.2.1 +scikit-learn==1.2.2 +scipy==1.13.0 +semantic-version==2.10.0 +sentencepiece==0.1.99 +sentry-sdk==2.0.0 +setproctitle==1.3.3 +setuptools==68.2.2 +shortuuid==1.0.13 +shtab==1.7.1 +simple-websocket==1.0.0 +six==1.16.0 +smmap==5.0.1 +sniffio==1.3.1 +soupsieve==2.5 +sqlitedict==2.1.0 +stack-data==0.6.3 +starlette==0.37.2 +svgwrite==1.4.3 +sympy==1.12 +tabledata==1.3.3 +tabulate==0.9.0 +tcolorpy==0.1.4 +tenacity==8.2.3 +terminado==0.18.1 +threadpoolctl==3.4.0 +thriftpy2==0.4.20 +tiktoken==0.6.0 +timm==0.9.16 +tinycss2==1.3.0 +tokenizers==0.15.2 +toml==0.10.2 +tomli==2.0.1 +toolz==0.12.1 +torch==2.1.2 +torchvision==0.16.2 +tornado==6.4 +tox==3.28.0 +tqdm-multiprocess==0.0.11 +tqdm==4.66.2 +traitlets==5.14.3 +transformers-stream-generator==0.0.5 +transformers==4.40.0.dev0 +triton==2.1.0 +typepy==1.3.2 +types-python-dateutil==2.9.0.20240316 +typing_extensions==4.11.0 +tyro==0.8.3 +tzdata==2024.1 +uc-micro-py==1.0.3 +uri-template==1.3.0 +urllib3==2.2.1 +uvicorn==0.29.0 +virtualenv==20.26.0 +wandb==0.16.5 +watchdog==4.0.0 +wavedrom==2.0.3.post3 +wcwidth==0.2.13 +webcolors==1.13 +webencodings==0.5.1 +websocket-client==1.8.0 +websockets==12.0 +wheel==0.41.2 +widgetsnbextension==4.0.10 +wrapt==1.16.0 +wsproto==1.2.0 +xxhash==3.4.1 +y-py==0.6.2 +yarl==1.9.4 +ypy-websocket==0.8.4 +zipp==3.18.1 +zstandard==0.22.0 \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_gqa_for_eval.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_gqa_for_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..2842975e7592162d352ee2263f2e1b56302ea4e2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_gqa_for_eval.py @@ -0,0 +1,18 @@ +import os +import json +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument("--src", type=str) +parser.add_argument("--dst", type=str) +args = parser.parse_args() + +all_answers = [] +for line_idx, line in enumerate(open(args.src)): + res = json.loads(line) + question_id = res["question_id"] + text = res["text"].rstrip(".").lower() + all_answers.append({"questionId": question_id, "prediction": text}) + +with open(args.dst, "w") as f: + json.dump(all_answers, f) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_mmvet_for_eval.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_mmvet_for_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..80ff3152042b5ea805a379436856bfef6ee030b4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_mmvet_for_eval.py @@ -0,0 +1,18 @@ +import os +import json +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument("--src", type=str) +parser.add_argument("--dst", type=str) +args = parser.parse_args() + +cur_result = {} + +for line in open(args.src): + data = json.loads(line) + qid = data["question_id"] + cur_result[f"v1_{qid}"] = data["text"] + +with open(args.dst, "w") as f: + json.dump(cur_result, f, indent=2) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_sqa_to_llava.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_sqa_to_llava.py new file mode 100644 index 0000000000000000000000000000000000000000..b0d242234b9777c64d6122c713be3c9d6d38c7a7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_sqa_to_llava.py @@ -0,0 +1,88 @@ +import json +import os +import fire +import re +from convert_sqa_to_llava_base_prompt import build_prompt_chatbot + + +def convert_to_llava(base_dir, split, prompt_format="QCM-LEA"): + split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[split] + problems = json.load(open(os.path.join(base_dir, "problems.json"))) + + split_problems = build_prompt_chatbot(problems, split_indices, prompt_format, use_caption=False, is_test=False) + + target_format = [] + for prob_id, (input, output) in split_problems.items(): + if input.startswith("Question: "): + input = input.replace("Question: ", "") + if output.startswith("Answer: "): + output = output.replace("Answer: ", "") + + raw_prob_data = problems[prob_id] + if raw_prob_data["image"] is None: + target_format.append( + { + "id": prob_id, + "conversations": [ + {"from": "human", "value": f"{input}"}, + {"from": "gpt", "value": f"{output}"}, + ], + } + ) + + else: + target_format.append( + { + "id": prob_id, + "image": os.path.join(prob_id, raw_prob_data["image"]), + "conversations": [ + {"from": "human", "value": f"{input}\n"}, + {"from": "gpt", "value": f"{output}"}, + ], + } + ) + + print(f"Number of samples: {len(target_format)}") + + with open(os.path.join(base_dir, f"llava_{split}_{prompt_format}.json"), "w") as f: + json.dump(target_format, f, indent=2) + + +def convert_to_jsonl(base_dir, split, prompt_format="QCM-LEPA"): + split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[split] + problems = json.load(open(os.path.join(base_dir, "problems.json"))) + + split_problems = build_prompt_chatbot(problems, split_indices, prompt_format, use_caption=False, is_test=False) + + writer = open(os.path.join(base_dir, f"scienceqa_{split}_{prompt_format}.jsonl"), "w") + for prob_id, (input, output) in split_problems.items(): + if input.startswith("Question: "): + input = input.replace("Question: ", "") + if output.startswith("Answer: "): + output = output.replace("Answer: ", "") + + raw_prob_data = problems[prob_id] + if raw_prob_data["image"] is None: + data = { + "id": prob_id, + "instruction": f"{input}", + "output": f"{output}", + } + + else: + data = { + "id": prob_id, + "image": os.path.join(prob_id, raw_prob_data["image"]), + "instruction": f"{input}\n", + "output": f"{output}", + } + writer.write(json.dumps(data) + "\n") + writer.close() + + +def main(task, **kwargs): + globals()[task](**kwargs) + + +if __name__ == "__main__": + fire.Fire(main) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_sqa_to_llava_base_prompt.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_sqa_to_llava_base_prompt.py new file mode 100644 index 0000000000000000000000000000000000000000..9a457dc4b9e6288d30c1cbd9df7d89b7e1474e75 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_sqa_to_llava_base_prompt.py @@ -0,0 +1,298 @@ +def get_question_text(problem): + question = problem["question"] + return question + + +def get_context_text(problem, use_caption): + txt_context = problem["hint"] + img_context = problem["caption"] if use_caption else "" + context = " ".join([txt_context, img_context]).strip() + if context == "": + context = "N/A" + return context + + +def get_choice_text(probelm, options): + choices = probelm["choices"] + choice_list = [] + for i, c in enumerate(choices): + choice_list.append("({}) {}".format(options[i], c)) + choice_txt = " ".join(choice_list) + # print(choice_txt) + return choice_txt + + +def get_answer(problem, options): + return options[problem["answer"]] + + +def get_lecture_text(problem): + # \\n: GPT-3 can generate the lecture with more tokens. + lecture = problem["lecture"].replace("\n", "\\n") + return lecture + + +def get_solution_text(problem): + # \\n: GPT-3 can generate the solution with more tokens + solution = problem["solution"].replace("\n", "\\n") + return solution + + +def create_one_example_chatbot(format, question, context, choice, answer, lecture, solution, test_example=True): + + input_format, output_format = format.split("-") + + ## Inputs + if input_format == "CQM": + input = f"Context: {context}\nQuestion: {question}\nOptions: {choice}\n" + elif input_format == "QCM": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\n" + # upper bound experiment + elif input_format == "QCML": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {lecture}\n" + elif input_format == "QCME": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {solution}\n" + elif input_format == "QCMLE": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {lecture} {solution}\n" + + elif input_format == "QCLM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {lecture}\nOptions: {choice}\n" + elif input_format == "QCEM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {solution}\nOptions: {choice}\n" + elif input_format == "QCLEM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {lecture} {solution}\nOptions: {choice}\n" + + # Outputs + if test_example: + output = "Answer:" + elif output_format == "A": + output = f"Answer: The answer is {answer}." + + elif output_format == "AL": + output = f"Answer: The answer is {answer}. BECAUSE: {solution}" + elif output_format == "AE": + output = f"Answer: The answer is {answer}. BECAUSE: {lecture}" + elif output_format == "ALE": + output = f"Answer: The answer is {answer}. BECAUSE: {lecture} {solution}" + elif output_format == "AEL": + output = f"Answer: The answer is {answer}. BECAUSE: {solution} {lecture}" + + elif output_format == "LA": + output = f"Answer: {lecture} The answer is {answer}." + elif output_format == "EA": + output = f"Answer: {solution} The answer is {answer}." + elif output_format == "LEA": + output = f"Answer: {lecture} {solution} The answer is {answer}." + elif output_format == "ELA": + output = f"Answer: {solution} {lecture} The answer is {answer}." + elif output_format == "LEPA": + output = "" + if len(lecture.strip()) > 0: + output += f"LECTURE: {lecture}\n" + if len(solution.strip()) > 0: + output += f"SOLUTION: {solution}\n" + output += "###\n" + output += f"ANSWER: {answer}." + + input = input.replace(" ", " ").strip() + output = output.replace(" ", " ").strip() + if input.endswith("BECAUSE:"): + input = input.replace("BECAUSE:", "").strip() + if output.endswith("BECAUSE:"): + output = output.replace("BECAUSE:", "").strip() + return input, output + + +def create_one_example(format, question, context, choice, answer, lecture, solution, test_example=True): + + input_format, output_format = format.split("-") + + ## Inputs + if input_format == "CQM": + input = f"Context: {context}\nQuestion: {question}\nOptions: {choice}\n" + elif input_format == "QCM": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\n" + # upper bound experiment + elif input_format == "QCML": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {lecture}\n" + elif input_format == "QCME": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {solution}\n" + elif input_format == "QCMLE": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {lecture} {solution}\n" + + elif input_format == "QCLM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {lecture}\nOptions: {choice}\n" + elif input_format == "QCEM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {solution}\nOptions: {choice}\n" + elif input_format == "QCLEM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {lecture} {solution}\nOptions: {choice}\n" + + # Outputs + if test_example: + output = "Answer:" + elif output_format == "A": + output = f"Answer: The answer is {answer}." + + elif output_format == "AL": + output = f"Answer: The answer is {answer}. BECAUSE: {solution}" + elif output_format == "AE": + output = f"Answer: The answer is {answer}. BECAUSE: {lecture}" + elif output_format == "ALE": + output = f"Answer: The answer is {answer}. BECAUSE: {lecture} {solution}" + elif output_format == "AEL": + output = f"Answer: The answer is {answer}. BECAUSE: {solution} {lecture}" + + elif output_format == "LA": + output = f"Answer: {lecture} The answer is {answer}." + elif output_format == "EA": + output = f"Answer: {solution} The answer is {answer}." + elif output_format == "LEA": + output = f"Answer: {lecture} {solution} The answer is {answer}." + elif output_format == "ELA": + output = f"Answer: {solution} {lecture} The answer is {answer}." + + text = input + output + text = text.replace(" ", " ").strip() + if text.endswith("BECAUSE:"): + text = text.replace("BECAUSE:", "").strip() + return text + + +def create_one_example_gpt4(format, question, context, choice, answer, lecture, solution, test_example=True): + + input_format, output_format = format.split("-") + + ## Inputs + if input_format == "CQM": + input = f"Context: {context}\nQuestion: {question}\nOptions: {choice}\n" + elif input_format == "QCM": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\n" + # upper bound experiment + elif input_format == "QCML": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {lecture}\n" + elif input_format == "QCME": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {solution}\n" + elif input_format == "QCMLE": + input = f"Question: {question}\nContext: {context}\nOptions: {choice}\nBECAUSE: {lecture} {solution}\n" + + elif input_format == "QCLM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {lecture}\nOptions: {choice}\n" + elif input_format == "QCEM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {solution}\nOptions: {choice}\n" + elif input_format == "QCLEM": + input = f"Question: {question}\nContext: {context}\nBECAUSE: {lecture} {solution}\nOptions: {choice}\n" + + # Outputs + if test_example: + output = "Answer:" + elif output_format == "A": + output = f"Answer: The answer is {answer}." + + elif output_format == "AL": + output = f"Answer: The answer is {answer}. BECAUSE: {solution}" + elif output_format == "AE": + output = f"Answer: The answer is {answer}. BECAUSE: {lecture}" + elif output_format == "ALE": + output = f"Answer: The answer is {answer}. BECAUSE: {lecture} {solution}" + elif output_format == "AEL": + output = f"Answer: The answer is {answer}. BECAUSE: {solution} {lecture}" + + elif output_format == "LA": + output = f"Answer: {lecture} The answer is {answer}." + elif output_format == "EA": + output = f"Answer: {solution} The answer is {answer}." + elif output_format == "LEA": + output = f"Answer: {lecture} {solution} The answer is {answer}." + elif output_format == "ELA": + output = f"Answer: {solution} {lecture} The answer is {answer}." + + input = input.replace(" ", " ").strip() + output = output.replace(" ", " ").strip() + if output.endswith("BECAUSE:"): + output = output.replace("BECAUSE:", "").strip() + + user_prompt = {"role": "user", "content": f"Can you explain {input}?"} + assistant_prompt = {"role": "assistant", "content": f"{output}"} + + return user_prompt, assistant_prompt + + +def build_prompt_chatbot(problems, shot_qids, prompt_format, use_caption=False, options=["A", "B", "C", "D", "E"], is_test=False): + examples = {} + + for qid in shot_qids: + question = get_question_text(problems[qid]) + context = get_context_text(problems[qid], use_caption) + choice = get_choice_text(problems[qid], options) + answer = get_answer(problems[qid], options) + lecture = get_lecture_text(problems[qid]).replace("\\n", "\n") + solution = get_solution_text(problems[qid]).replace("\\n", "\n") + + train_example = create_one_example_chatbot(prompt_format, question, context, choice, answer, lecture, solution, test_example=is_test) + examples[qid] = train_example + return examples + + +def build_prompt(problems, shot_qids, test_qid, args): + + examples = [] + + # n-shot training examples + for qid in shot_qids: + question = get_question_text(problems[qid]) + context = get_context_text(problems[qid], args.use_caption) + choice = get_choice_text(problems[qid], args.options) + answer = get_answer(problems[qid], args.options) + lecture = get_lecture_text(problems[qid]) + solution = get_solution_text(problems[qid]) + + train_example = create_one_example(args.prompt_format, question, context, choice, answer, lecture, solution, test_example=False) + examples.append(train_example) + + # test example + question = get_question_text(problems[test_qid]) + context = get_context_text(problems[test_qid], args.use_caption) + choice = get_choice_text(problems[test_qid], args.options) + answer = get_answer(problems[test_qid], args.options) + lecture = get_lecture_text(problems[test_qid]) + solution = get_solution_text(problems[test_qid]) + + test_example = create_one_example(args.prompt_format, question, context, choice, answer, lecture, solution, test_example=True) + examples.append(test_example) + + # create the prompt input + prompt_input = "\n\n".join(examples) + + return prompt_input + + +def build_prompt_gpt4(problems, shot_qids, test_qid, args): + + prompt_array = [{"role": "system", "content": "You are a helpful assistant."}] + + # n-shot training examples + for qid in shot_qids: + question = get_question_text(problems[qid]) + context = get_context_text(problems[qid], args.use_caption) + choice = get_choice_text(problems[qid], args.options) + answer = get_answer(problems[qid], args.options) + lecture = get_lecture_text(problems[qid]) + solution = get_solution_text(problems[qid]) + + user_prompt, assistant_prompt = create_one_example_gpt4(args.prompt_format, question, context, choice, answer, lecture, solution, test_example=False) + prompt_array.append(user_prompt) + prompt_array.append(assistant_prompt) + + # test example + question = get_question_text(problems[test_qid]) + context = get_context_text(problems[test_qid], args.use_caption) + choice = get_choice_text(problems[test_qid], args.options) + answer = get_answer(problems[test_qid], args.options) + lecture = get_lecture_text(problems[test_qid]) + solution = get_solution_text(problems[test_qid]) + + user_prompt, assistant_prompt = create_one_example_gpt4(args.prompt_format, question, context, choice, answer, lecture, solution, test_example=True) + prompt_array.append(user_prompt) + prompt_array.append(assistant_prompt) + + return prompt_array diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_vizwiz_for_submission.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_vizwiz_for_submission.py new file mode 100644 index 0000000000000000000000000000000000000000..80b8253981831333b713a9eb433ddf0f626535b5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_vizwiz_for_submission.py @@ -0,0 +1,45 @@ +import os +import argparse +import json + +from llava.eval.m4c_evaluator import EvalAIAnswerProcessor + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--annotation-file", type=str, required=True) + parser.add_argument("--result-file", type=str, required=True) + parser.add_argument("--result-upload-file", type=str, required=True) + return parser.parse_args() + + +if __name__ == "__main__": + + args = parse_args() + + os.makedirs(os.path.dirname(args.result_upload_file), exist_ok=True) + + results = [] + error_line = 0 + for line_idx, line in enumerate(open(args.result_file)): + try: + results.append(json.loads(line)) + except: + error_line += 1 + results = {x["question_id"]: x["text"] for x in results} + test_split = [json.loads(line) for line in open(args.annotation_file)] + split_ids = set([x["question_id"] for x in test_split]) + + print(f"total results: {len(results)}, total split: {len(test_split)}, error_line: {error_line}") + + all_answers = [] + + answer_processor = EvalAIAnswerProcessor() + + for x in test_split: + # import pdb; pdb.set_trace() + assert x["question_id"] in results, print(x) + all_answers.append({"image": x["image"], "answer": answer_processor(results[x["question_id"]])}) + + with open(args.result_upload_file, "w") as f: + json.dump(all_answers, f) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_vqav2_for_submission.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_vqav2_for_submission.py new file mode 100644 index 0000000000000000000000000000000000000000..f0a8057954570c1e87463e01bf08dfce0f720ab7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/convert_vqav2_for_submission.py @@ -0,0 +1,50 @@ +import os +import argparse +import json + +from llava.eval.m4c_evaluator import EvalAIAnswerProcessor + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--dir", type=str, default="./playground/data/eval/vqav2") + parser.add_argument("--ckpt", type=str, required=True) + parser.add_argument("--split", type=str, required=True) + return parser.parse_args() + + +if __name__ == "__main__": + + args = parse_args() + + src = os.path.join(args.dir, "answers", args.split, args.ckpt, "merge.jsonl") + test_split = os.path.join(args.dir, "llava_vqav2_mscoco_test2015.jsonl") + dst = os.path.join(args.dir, "answers_upload", args.split, f"{args.ckpt}.json") + os.makedirs(os.path.dirname(dst), exist_ok=True) + + results = [] + error_line = 0 + for line_idx, line in enumerate(open(src)): + try: + results.append(json.loads(line)) + except: + error_line += 1 + + results = {x["question_id"]: x["text"] for x in results} + test_split = [json.loads(line) for line in open(test_split)] + split_ids = set([x["question_id"] for x in test_split]) + + print(f"total results: {len(results)}, total split: {len(test_split)}, error_line: {error_line}") + + all_answers = [] + + answer_processor = EvalAIAnswerProcessor() + + for x in test_split: + if x["question_id"] not in results: + all_answers.append({"question_id": x["question_id"], "answer": ""}) + else: + all_answers.append({"question_id": x["question_id"], "answer": answer_processor(results[x["question_id"]])}) + + with open(dst, "w") as f: + json.dump(all_answers, open(dst, "w")) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/data_info.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/data_info.py new file mode 100644 index 0000000000000000000000000000000000000000..d4aa7a5ba394c4615e705a233fa6a714fa1cf3f1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/data_info.py @@ -0,0 +1,124 @@ +import json +import os +from PIL import Image +from tqdm import tqdm +import matplotlib.pyplot as plt +import numpy as np + + +def load_data(json_path): + with open(json_path, "r") as f: + return json.load(f) + + +def filter_data(data): + # filtered_data = [item for item in data if "image" in item and "text" in item["image"]] + filtered_data = [item for item in data if "image" in item] + return filtered_data + + +from multiprocessing import Pool +import functools + + +def calculate_image_dimension(item, images_folder): + image_path = os.path.join(images_folder, item["image"]) + try: + with Image.open(image_path) as img: + width, height = img.size + return width, height + except Exception as e: + print(f"Error opening {image_path}: {e}") + return None, None + + +def calculate_image_dimensions_multiprocess(filtered_data, images_folder, num_processes=256): + with Pool(num_processes) as p: + dimensions = list(tqdm(p.imap(functools.partial(calculate_image_dimension, images_folder=images_folder), filtered_data), total=len(filtered_data), desc="Calculating image dimensions")) + widths, heights = zip(*[dim for dim in dimensions if dim[0] is not None]) + return list(widths), list(heights) + + +def tokenize(text): + return text.split() + + +def calculate_tokenized_lengths(data): + lengths = [] + for item in tqdm(data, desc="Tokenizing conversations"): + for conversation in item["conversations"]: + tokenized_value = tokenize(conversation["value"]) + lengths.append(len(tokenized_value)) + return lengths + + +import argparse + + +def main(): + parser = argparse.ArgumentParser(description="Process data for LLaVA_Next project.") + parser.add_argument("--json_path", type=str, help="Path to the JSON file containing data.") + parser.add_argument("--images_folder", type=str, default="/mnt/bn/vl-research/data/llava_data", help="Path to the folder containing images.") + args = parser.parse_args() + + llava_instruct_name = args.json_path.split("/")[-1].replace(".json", "") + json_path = args.json_path + llava_instruct_name = os.path.basename(json_path).replace(".json", "") + images_folder = args.images_folder + + data = load_data(json_path) + filtered_data = filter_data(data) + + if len(filtered_data) != 0: + print(f"Total data items: {len(data)}, Filtered data items: {len(filtered_data)}") + widths, heights = calculate_image_dimensions_multiprocess(filtered_data, images_folder) + max_width = max(widths) + max_height = max(heights) + print(f"Max width: {max_width}, Max height: {max_height}") + + tokenized_lengths = calculate_tokenized_lengths(data) + + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 12)) + + if len(filtered_data) != 0: + # Plot 2D histogram + if min(widths) == max(widths): + widths_bins = [min(widths), max(widths) + 1] + else: + widths_bins = np.arange(min(widths), max(widths) + 100, 100) + + if min(heights) == max(heights): + heights_bins = [min(heights), max(heights) + 1] + else: + heights_bins = np.arange(min(heights), max(heights) + 100, 100) + + h, xedges, yedges, image = ax1.hist2d(widths, heights, bins=[widths_bins, heights_bins], cmap=plt.cm.jet, density=True) + fig.colorbar(image, ax=ax1) + ax1.set_xlabel("Width") + ax1.set_ylabel("Height") + ax1.set_title(f"dist_{llava_instruct_name}_2d_w_h\nMax width: {max(widths)}, Max height: {max(heights)}", fontsize=10) + + # Plot histogram + hist, bin_edges = np.histogram(tokenized_lengths, bins=np.arange(0, max(tokenized_lengths) + 10, 100)) + bins = np.arange(0, max(tokenized_lengths) + 10, 100) + ax2.bar(bin_edges[:-1], hist, width=7, edgecolor="black", log=True) + + # Display every nth label on the x-axis + n = 8 # Adjust this value to control the number of labels displayed + ticks = bins[::n] + tick_labels = [int(tick) for tick in ticks] + ax2.set_xticks(ticks) + ax2.set_xticklabels(tick_labels, rotation=90, fontsize=8) + + ax2.set_xlim(min(bin_edges), max(bin_edges)) + ax2.set_xlabel("Tokenized Length") + ax2.set_ylabel("Count (log scale)") + ax2.set_title(f"dist_{llava_instruct_name}_tokenized_length", fontsize=8) + + plt.tight_layout() + plt.savefig(f"/mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next/notebooks/sft_data/dist_{llava_instruct_name}_combined.png") + print(f"Plots saved to /mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next/notebooks/sft_data/dist_{llava_instruct_name}_combined.png") + + +if __name__ == "__main__": + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/dpo_data_info.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/dpo_data_info.py new file mode 100644 index 0000000000000000000000000000000000000000..ea60ec1927874a5318e0230382106144d690db88 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/dpo_data_info.py @@ -0,0 +1,67 @@ +import json +import re + +json_path = "/mnt/bn/vl-research/workspace/boli01/projects/sft_data_workspace/vlfeedback_80k.jsonl" + +with open(json_path, "r") as f: + data = f.readlines() + +data = [json.loads(d) for d in data] + + +def convert_format(original_data, dimension="Visual Faithfulness"): + converted_data = [] + for item in original_data: + # Assuming the best response is the one with the highest helpfulness rating + best_completion = max(item["completions"], key=lambda x: int(x["annotations"]["Helpfulness"]["Rating"])) + best_response = best_completion["response"] + best_model = best_completion["model"] + + if "†source" in best_response: + print(best_response) + # Regex pattern to match the pattern 【digit†source】 + pattern = r"【\d+†source】" + # Replace the matched patterns with an empty string + cleaned_text = re.sub(pattern, "", best_response) + best_response = cleaned_text + print(f"*****************************************") + print(best_response) + + # Assuming the worst response is the one with the lowest helpfulness rating + worst_completion = min(item["completions"], key=lambda x: int(x["annotations"]["Helpfulness"]["Rating"])) + worst_response = worst_completion["response"] + + if "†source" in worst_response: + print(worst_response) + # Regex pattern to match the pattern ��digit†source】 + pattern = r"【\d+†source】" + # Replace the matched patterns with an empty string + cleaned_text = re.sub(pattern, "", worst_response) + worst_response = cleaned_text + print(f"*****************************************") + print(worst_response) + + # Extract scores + best_score = int(best_completion["annotations"][dimension]["Rating"]) + worst_score = int(worst_completion["annotations"][dimension]["Rating"]) + + # Construct the new format + new_item = { + "id": item["id"], + "prompt": item["prompt"], + "answer": "", + "image": f"silkie_dpo/{item['id']}.jpg", # Assuming the video ID is the last part of the original ID + "chosen": best_response, + "rejected": worst_response, + "chosen_score": best_score, + "rejected_score": worst_score, + } + converted_data.append(new_item) + + return converted_data + + +for dimension in ["Visual Faithfulness", "Helpfulness", "Ethical Considerations"]: + converted_data = convert_format(data, dimension=dimension) + with open(f"/mnt/bn/vl-research/data/llava_instruct/dpo_data/silkie_dpo_data_{dimension.replace(' ', '_').lower()}_{len(converted_data)}.json", "w") as f: + json.dump(converted_data, f, indent=4) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/entry_cmd.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/entry_cmd.sh new file mode 100644 index 0000000000000000000000000000000000000000..6f1f41f245b80ff723ade1abfea96ff3c83d69ce --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/entry_cmd.sh @@ -0,0 +1,30 @@ +python3 -m pip install --upgrade pip; + +export http_proxy=http://sys-proxy-rd-relay.byted.org:8118; +export https_proxy=http://sys-proxy-rd-relay.byted.org:8118; + +export HF_HOME=/mnt/bn/vl-research-boli01-cn/.cache/huggingface; +export HF_TOKEN="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"; +export HF_HUB_ENABLE_HF_TRANSFER="1"; + +cd /mnt/bn/vl-research-boli01-cn/projects/zzz/lmms-eval; +pip install -e .; + +cd /mnt/bn/vl-research-boli01-cn/projects/zzz/LLaVA_Next; +pip install -e .; + +python3 -m pip install ninja; +python3 -m pip install flash-attn --no-build-isolation; + +bash /mnt/bn/vl-research-boli01-cn/projects/zzz/LLaVA_Next/cn_scripts/vicuna/internal0.6m_finetune_llava1.6mix_7b_v0.2_unfreeze.sh + + +accelerate launch --num_processes 8 --main_process_port 12345 -m lmms_eval \ + --model llava \ + --model_args pretrained="/mnt/bn/vl-research-boli01-cn/projects/zzz/LLaVA_Next/internal_project_checkpoints/llavanext-lmsys_vicuna-7b-v1.5-clip-vit-large-patch14-336-mlp2x_gelu-pretrain_internal0.6m_vicuna_v1_finetune_llava1.6_datamix_unfreezeVIS_1e" \ + --tasks ok_vqa,textcaps_val,mme_test,mmmu,cmmmu,coco2017_cap_val,vizwiz_vqa_val,ai2d,chartqa,pope \ + --batch_size 1 \ + --log_samples \ + --log_samples_suffix debug \ + --output_path ./logs/ \ + --wandb_args 'project=llava-next-lmms-eval,job_type=eval'; \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune.sh new file mode 100644 index 0000000000000000000000000000000000000000..9d1503682b355ecab9cb55f57f24fa4c57e46581 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune.sh @@ -0,0 +1,95 @@ +#!/bin/bash + +cd /mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install -U transformers +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + +# Get the latest version of deepspeed from PyPI +latest_version=$(yolk -V deepspeed | cut -d ' ' -f 2) + +# Check if the installed version is not the latest + # pip install deepspeed==0.12.2 +if [ "$installed_version" != "$latest_version" ]; then + pip install deepspeed==0.12.2 +fi + +# Install flash-attn if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + +################## VICUNA ################## +PROMPT_VERSION=v1 +MODEL_VERSION="vicuna-7b-v1-5" +################## VICUNA ################## + + +################## project ################## +PROJECT_NAME="ds_llava-vicuna-7b-v1-5-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME="mixtral_instruct_158K_V1" + +# wandb configure +export WANDB_API_KEY="03fc62d68025c9498cf6493432551badd7d4f953" +wandb login $WANDB_API_KEY + +export WANDB_NAME=$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME + +export WANDB_PROJECT=LLaVA_Mixtral + +export WANDB_MODE=online + +# wandb online + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data/coco/train2017 \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/$PROJECT_NAME/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava--$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME--finetune \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_1.5.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_1.5.sh new file mode 100644 index 0000000000000000000000000000000000000000..13cb818b7a01413d2a11dc8f4b8154ad688979b7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_1.5.sh @@ -0,0 +1,99 @@ +#!/bin/bash +dataset_name=$1 + +# Uncomment and set the following variables correspondingly to run this script: + +cd /mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install -U transformers +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + +# Get the latest version of deepspeed from PyPI +latest_version=$(yolk -V deepspeed | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install deepspeed==0.12.2 +fi + +# Install yolk3k if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + + +################## VICUNA ################## +PROMPT_VERSION=v1 +MODEL_VERSION="vicuna-7b-v1-5" +################## VICUNA ################## + +################## project ################## +PROJECT_NAME="ds_llava-vicuna-7b-v1-5-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME=$dataset_name + + +# wandb configure +export WANDB_API_KEY="03fc62d68025c9498cf6493432551badd7d4f953" +wandb login $WANDB_API_KEY + +export WANDB_NAME=$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME + +export WANDB_PROJECT=LLaVA_Mixtral + +export WANDB_MODE=online + +wandb online + + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/$PROJECT_NAME/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava--$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME--finetune \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_full_schedule.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_full_schedule.sh new file mode 100644 index 0000000000000000000000000000000000000000..9769666db9424808a896d322016ae86a2bf32a19 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_full_schedule.sh @@ -0,0 +1,46 @@ +#!/bin/bash + +# Uncomment and set the following variables correspondingly to run this script: + +################## VICUNA ################## +# PROMPT_VERSION=v1 +# MODEL_VERSION="vicuna-v1-3-7b" +################## VICUNA ################## + +################## LLaMA-2 ################## +# PROMPT_VERSION="llava_llama_2" +# MODEL_VERSION="llama-2-7b-chat" +################## LLaMA-2 ################## + +deepspeed llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/llava_instruct_158k.json \ + --image_folder /path/to/coco/train2017 \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/llava-$MODEL_VERSION-pretrain/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava-$MODEL_VERSION-finetune \ + --num_train_epochs 3 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_lora.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_lora.sh new file mode 100644 index 0000000000000000000000000000000000000000..5ff90c0247a5072eb174ca7fad08c45b8880b317 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_lora.sh @@ -0,0 +1,47 @@ +#!/bin/bash + +# Uncomment and set the following variables correspondingly to run this script: + +################## VICUNA ################## +# PROMPT_VERSION=v1 +# MODEL_VERSION="vicuna-v1-3-7b" +################## VICUNA ################## + +################## LLaMA-2 ################## +# PROMPT_VERSION="llava_llama_2" +# MODEL_VERSION="llama-2-7b-chat" +################## LLaMA-2 ################## + +deepspeed llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --lora_enable True \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/llava_instruct_80k.json \ + --image_folder /path/to/coco/train2017 \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/llava-$MODEL_VERSION-pretrain/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava-$MODEL_VERSION-finetune_lora \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --lazy_preprocess True \ + --dataloader_num_workers 16 \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral.sh new file mode 100644 index 0000000000000000000000000000000000000000..f7ca3836143715124f8724b1f92d64b04a9f1856 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral.sh @@ -0,0 +1,96 @@ +#!/bin/bash + +cd /mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install -U transformers +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + +# Get the latest version of deepspeed from PyPI +latest_version=$(yolk -V deepspeed | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install deepspeed==0.12.2 +fi + +# Install yolk3k if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + + +################## MISTRAL ################## +PROMPT_VERSION=mistral_instruct +MODEL_VERSION="Mistral-7B-Instruct-v0.2" +################## VICUNA ################## + + +################## project ################## +PROJECT_NAME="ds_llava-Mistral-7B-Instruct-v0.2-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME="mixtral_instruct_158K_V1" + +# wandb configure +export WANDB_API_KEY="03fc62d68025c9498cf6493432551badd7d4f953" +wandb login $WANDB_API_KEY + +export WANDB_NAME=$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME + +export WANDB_PROJECT=LLaVA_Mixtral + +export WANDB_MODE=online + +wandb online + + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data/coco/train2017 \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/$PROJECT_NAME/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava--$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME--finetune \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.5.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.5.sh new file mode 100644 index 0000000000000000000000000000000000000000..71f4ed8aba11fca1ad18979498b8c7ca7d7d5fa6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.5.sh @@ -0,0 +1,96 @@ +#!/bin/bash +dataset_name=$1 + +cd /mnt/bn/vl-research/workspace/yhzhang/LLaVA + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install -U transformers +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + +# Get the latest version of deepspeed from PyPI +# latest_version=$(yolk -V deepspeed | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "0.12.2" ]; then + pip install deepspeed==0.12.2 +fi + +# Install yolk3k if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + +################## MISTRAL ################## +PROMPT_VERSION=mistral_instruct +MODEL_VERSION="Mistral-7B-Instruct-v0.2" +################## MISTRAL ################## + + +################## project ################## +PROJECT_NAME="ds_llava-Mistral-7B-Instruct-v0.2-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME=$dataset_name + + +# wandb configure +export WANDB_API_KEY="03fc62d68025c9498cf6493432551badd7d4f953" +wandb login $WANDB_API_KEY + +export WANDB_NAME=$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME + +export WANDB_PROJECT=LLaVA_Mixtral + +export WANDB_MODE=online + +wandb online + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/$PROJECT_NAME/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava--$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME--finetune \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True + # --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres.sh new file mode 100644 index 0000000000000000000000000000000000000000..28b2e0b257044fbd1d222c9aebb033d8c63d489a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres.sh @@ -0,0 +1,100 @@ +#!/bin/bash +dataset_name=$1 + +cd /mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +pip install pydantic + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "4.36.2" ]; then + pip install transformers==4.36.2 +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + + +# Check if the installed version is not the latest +if [ "$installed_version" != "0.12.2" ]; then + pip install deepspeed==0.12.2 +fi + +# Install flash-atten if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + +################## MISTRAL ################## +PROMPT_VERSION=mistral_instruct +MODEL_VERSION="Mistral-7B-Instruct-v0.2" +################## MISTRAL ################## + + +################## project ################## +PROJECT_NAME="ds_llava-Mistral-7B-Instruct-v0.2-clip_large_336px-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME=$dataset_name + + +# wandb configure +export WANDB_API_KEY=e464cc107357c7b38e87f239bc3eb2ce5fb73c7c +export WANDB_PROJECT=llava + +export WANDB_NAME=$PROJECT_NAME--$DATA_NAME--336px--anyres--sft + +export WANDB_MODE=online + +wandb online + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero3.json \ + --model_name_or_path /mnt/bn/vl-research/workspace/project/2023/LLaVA/checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data \ + --vision_tower openai/clip-vit-large-patch14-336 \ + --pretrain_mm_mlp_adapter /mnt/bn/vl-research/workspace/project/2023/LLaVA/checkpoints/ds_llava-Mistral-7B-Instruct-v0.2-clip_large_336px-mlp2x_gelu-pretrain_blip558k_plain/mm_projector.bin \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --unfreeze_mm_vision_tower True \ + --mm_vision_tower_lr 2e-6 \ + --image_aspect_ratio anyres \ + --image_grid_pinpoints "[(336, 672), (672, 336), (672, 672), (1008, 336), (336, 1008)]" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --output_dir ./checkpoints/$PROJECT_NAME--$DATA_NAME--336px--anyres--sft \ + --num_train_epochs 9 \ + --per_device_train_batch_size 8 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "epoch" \ + --save_steps 1500 \ + --learning_rate 5e-6 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 4096 \ + --gradient_checkpointing True \ + --dataloader_num_workers 8 \ + --lazy_preprocess True \ + --report_to wandb + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres_freeze_vision.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres_freeze_vision.sh new file mode 100644 index 0000000000000000000000000000000000000000..e04f4871f4da95c4c442522c0aa3f5c3829ff78e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres_freeze_vision.sh @@ -0,0 +1,97 @@ +#!/bin/bash +dataset_name=$1 + +cd /mnt/bn/vl-research/workspace/yhzhang/LLaVA + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +pip install pydantic + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "4.36.2" ]; then + pip install transformers==4.36.2 +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + + +# Check if the installed version is not the latest +if [ "$installed_version" != "0.12.2" ]; then + pip install deepspeed==0.12.2 +fi + +# Install flash-atten if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + +################## MISTRAL ################## +PROMPT_VERSION=mistral_instruct +MODEL_VERSION="Mistral-7B-Instruct-v0.2" +################## MISTRAL ################## + + +################## project ################## +PROJECT_NAME="ds_llava-Mistral-7B-Instruct-v0.2-clip_large_336px-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME=$dataset_name + + +# wandb configure +export WANDB_API_KEY=e464cc107357c7b38e87f239bc3eb2ce5fb73c7c +export WANDB_PROJECT=llava + +export WANDB_NAME=$PROJECT_NAME--$DATA_NAME--336px--unfreeze--anyres--sft + +export WANDB_MODE=online + +wandb online + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero3.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data \ + --vision_tower openai/clip-vit-large-patch14-336 \ + --pretrain_mm_mlp_adapter /mnt/bn/vl-research/workspace/project/2023/LLaVA/checkpoints/ds_llava-Mistral-7B-Instruct-v0.2-clip_large_336px-mlp2x_gelu-pretrain_blip558k_plain/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres \ + --image_grid_pinpoints "[(336, 672), (672, 336), (672, 672), (1008, 336), (336, 1008)]" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --output_dir ./checkpoints/$PROJECT_NAME--$DATA_NAME--336px--anyres--unfreeze--sft \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres_lmms_eval.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres_lmms_eval.sh new file mode 100644 index 0000000000000000000000000000000000000000..c31fdc53fd807d866e49091c1735c4969ed2b5f7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_1.6_336px_anyres_lmms_eval.sh @@ -0,0 +1,78 @@ +#!/bin/bash + +# set up wandb +export WANDB_API_KEY=a651c244635bc6f913ab654af3f0eebaecdc9381 +export WANDB_ENTITY=llava-vl +export WANDB_PROJECT=llava-next +export PYTHONWARNINGS="ignore" + +cd /mnt/bn/vl-research/workspace/boli01/projects/lmms-eval + +pip install -e . + +# set up llava dev env +cd /mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next + +################## MISTRAL ################## +PROMPT_VERSION=mistral_instruct +MODEL_VERSION="Mistral-7B-Instruct-v0.2" +################## MISTRAL ################## + +################## project ################## +PROJECT_NAME="ds_llava-Mistral-7B-Instruct-v0.2-clip_large_336px-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME='llava_caps20k_chartqa19k' + +export WANDB_NAME=$PROJECT_NAME--$DATA_NAME--336px--anyres--sft +export WANDB_MODE=online + +wandb online + +CUDA_VISIBLE_DEVICES="0,1,2,3,4,5,6,7" deepspeed --master_port 26000 --include localhost:0,1,2,3,4,5,6,7 llava/train/train_mem.py \ + --deepspeed ./scripts/zero3_offload.json \ + --model_name_or_path mistralai/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/llava_instruct/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/data/llava \ + --vision_tower openai/clip-vit-large-patch14-336 \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --unfreeze_mm_vision_tower True \ + --mm_vision_tower_lr 2e-6 \ + --image_aspect_ratio anyres \ + --image_grid_pinpoints "[(336, 672), (672, 336), (672, 672), (1008, 336), (336, 1008)]" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --output_dir ./checkpoints/$PROJECT_NAME--llava1.6--336px--anyres--sft \ + --num_train_epochs 1 \ + --per_device_train_batch_size 8 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 1500 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 4096 \ + --gradient_checkpointing True \ + --dataloader_num_workers 32 \ + --lazy_preprocess True \ + --report_to wandb \ + --run_name $WANDB_NAME +# starting here is the args for evaluation + --eval_num_processes 4 \ + --task_names mme,docvqa_val \ + --model_args pretrained=./checkpoints/$PROJECT_NAME--$DATA_NAME--336px--anyres--sft \ + --limit 8 \ + --batch_size 1 \ + --log_samples \ + --log_samples_suffix debug \ + --output_path ./logs/ diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_copy.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_copy.sh new file mode 100644 index 0000000000000000000000000000000000000000..23cab89db08ec4557659c4810410bfff438a23b6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_mixtral_copy.sh @@ -0,0 +1,96 @@ +#!/bin/bash + +cd /mnt/bn/vl-research/workspace/boli01/zzzprojects/LLaVA + +# Install yolk3k if not installed +if ! pip show yolk3k > /dev/null 2>&1; then + pip install yolk3k +fi + +# Get the installed version of transformers +installed_version=$(pip show transformers | grep Version | cut -d ' ' -f 2) + +# Get the latest version of transformers from PyPI +latest_version=$(yolk -V transformers | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install -U transformers +fi + +# Get the installed version of deepspeed +installed_version=$(pip show deepspeed | grep Version | cut -d ' ' -f 2) + +# Get the latest version of deepspeed from PyPI +latest_version=$(yolk -V deepspeed | cut -d ' ' -f 2) + +# Check if the installed version is not the latest +if [ "$installed_version" != "$latest_version" ]; then + pip install deepspeed==0.12.2 +fi + +# Install yolk3k if not installed +if ! pip show flash-attn > /dev/null 2>&1; then + pip install flash-attn --no-build-isolation +fi + + +################## MISTRAL ################## +PROMPT_VERSION=mistral_instruct +MODEL_VERSION="Mistral-7B-Instruct-v0.2" +################## VICUNA ################## + + +################## project ################## +PROJECT_NAME="ds_llava-Mistral-7B-Instruct-v0.2-mlp2x_gelu-pretrain_blip558k_plain" + +################## data ################## +DATA_NAME="llava_instruct_150k" + +# wandb configure +export WANDB_API_KEY="03fc62d68025c9498cf6493432551badd7d4f953" +wandb login $WANDB_API_KEY + +export WANDB_NAME=$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME + +export WANDB_PROJECT=LLaVA_Mixtral + +export WANDB_MODE=online + +wandb online + + +deepspeed --master_port 26000 \ + llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/$DATA_NAME.json \ + --image_folder /mnt/bn/vl-research/workspace/boli01/data/playground/data/coco/train2017 \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/$PROJECT_NAME/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava--$PROJECT_NAME--$MODEL_VERSION--$DATA_NAME--finetune \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_qlora.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_qlora.sh new file mode 100644 index 0000000000000000000000000000000000000000..05be856288274653ecb14f48c667ff5ca8ce1464 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_qlora.sh @@ -0,0 +1,48 @@ +#!/bin/bash + +# Uncomment and set the following variables correspondingly to run this script: + +################## VICUNA ################## +# PROMPT_VERSION=v1 +# MODEL_VERSION="vicuna-v1-3-7b" +################## VICUNA ################## + +################## LLaMA-2 ################## +# PROMPT_VERSION="llava_llama_2" +# MODEL_VERSION="llama-2-7b-chat" +################## LLaMA-2 ################## + +deepspeed llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --lora_enable True \ + --bits 4 \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path ./playground/data/llava_instruct_80k.json \ + --image_folder /path/to/coco/train2017 \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/llava-$MODEL_VERSION-pretrain/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava-$MODEL_VERSION-finetune_lora \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --lazy_preprocess True \ + --dataloader_num_workers 16 \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_sqa.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_sqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..ac1359ce9eeffb5e6aae8bdc44425b84e5e642aa --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/finetune_sqa.sh @@ -0,0 +1,34 @@ +#!/bin/bash + +deepspeed llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path lmsys/vicuna-13b-v1.3 \ + --version $PROMPT_VERSION \ + --data_path /Data/ScienceQA/data/scienceqa/llava_train_QCM-LEA.json \ + --image_folder /Data/ScienceQA/data/scienceqa/images/train \ + --vision_tower openai/clip-vit-large-patch14 \ + --pretrain_mm_mlp_adapter ./checkpoints/huggingface/liuhaotian/llava-pretrain-vicuna-13b-v1.3/mm_projector.bin \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava-vicuna-13b-v1.3-pretrain_lcs558k_plain-ScienceQA_QCM_LEA-12e \ + --num_train_epochs 12 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 50000 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/merge_lora_weights.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/merge_lora_weights.py new file mode 100644 index 0000000000000000000000000000000000000000..90b4aa0f903a3b345556213ddf27595319263e06 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/merge_lora_weights.py @@ -0,0 +1,22 @@ +import argparse +from llava.model.builder import load_pretrained_model +from llava.mm_utils import get_model_name_from_path + + +def merge_lora(args): + model_name = get_model_name_from_path(args.model_path) + tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name, device_map="cpu") + + model.save_pretrained(args.save_model_path) + tokenizer.save_pretrained(args.save_model_path) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--model-path", type=str, required=True) + parser.add_argument("--model-base", type=str, required=True) + parser.add_argument("--save-model-path", type=str, required=True) + + args = parser.parse_args() + + merge_lora(args) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/pretrain.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/pretrain.sh new file mode 100644 index 0000000000000000000000000000000000000000..f3cf7d94e59e55e6a4942e3917b1eadffe6c9a86 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/pretrain.sh @@ -0,0 +1,43 @@ +#!/bin/bash + +# Uncomment and set the following variables correspondingly to run this script: + +# MODEL_VERSION=vicuna-v1-3-7b +# MODEL_VERSION=llama-2-7b-chat + +########### DO NOT CHANGE ########### +########### USE THIS FOR BOTH ########### +PROMPT_VERSION=plain +########### DO NOT CHANGE ########### + +deepspeed llava/train/train_mem.py \ + --deepspeed ./scripts/zero2.json \ + --model_name_or_path ./checkpoints/$MODEL_VERSION \ + --version $PROMPT_VERSION \ + --data_path /path/to/pretrain_data.json \ + --image_folder /path/to/images \ + --vision_tower openai/clip-vit-large-patch14 \ + --tune_mm_mlp_adapter True \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir ./checkpoints/llava-$MODEL_VERSION-pretrain \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 24000 \ + --learning_rate 2e-3 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 2048 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/quick_check.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/quick_check.py new file mode 100644 index 0000000000000000000000000000000000000000..ca7cff9de618e59cfdd84925a9f34c39cde38ff1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/quick_check.py @@ -0,0 +1,57 @@ +import json +import os +import argparse +from tqdm import tqdm +import yaml + + +def check_missing_images(json_path, images_folder): + data = json.load(open(json_path, "r")) + missing_data = [] + + for i, d in enumerate(tqdm(data)): + image = d["image"] if "image" in d else "" + if image != "": + path = os.path.join(images_folder, image) + if not os.path.exists(path): + print(f"Missing image: {path}") + missing_data.append(d) + + return missing_data + + +def read_yaml_to_llava_data(yaml_path, images_folder): + print(f"Reading YAML file: {yaml_path}") + with open(yaml_path, "r") as f: + data = yaml.safe_load(f) + + llava_json_paths = data["datasets"] + for item in llava_json_paths: + json_path = item["json_path"] + missing_data = check_missing_images(json_path, images_folder) + if len(missing_data) > 0: + print(f"Missing images in {json_path}:") + for d in missing_data: + print(d) + + +def direct_check_llava_data(json_path, images_folder): + missing_data = check_missing_images(json_path, images_folder) + if len(missing_data) > 0: + print(f"Missing images in {json_path}:") + for d in missing_data: + print(d) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Check for missing images in dataset.") + parser.add_argument("--yaml_path", type=str, default="", help="Path to the YAML file containing the dataset.") + parser.add_argument("--json_path", type=str, default="", help="Path to the JSON file containing the dataset.") + parser.add_argument("--images_folder", type=str, default="/mnt/bn/vl-research/data/llava_data", help="Path to the folder containing the images.") + + args = parser.parse_args() + + if args.json_path != "": + direct_check_llava_data(args.json_path, args.images_folder) + elif args.yaml_path != "": + read_yaml_to_llava_data(args.yaml_path, args.images_folder) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/sqa_eval_batch.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/sqa_eval_batch.sh new file mode 100644 index 0000000000000000000000000000000000000000..adbf46ef7a6e86181b5927002597ef786add5bde --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/sqa_eval_batch.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +CHUNKS=8 +for IDX in {0..7}; do + CUDA_VISIBLE_DEVICES=$IDX python -m llava.eval.model_vqa_science \ + --model-path liuhaotian/llava-lcs558k-scienceqa-vicuna-13b-v1.3 \ + --question-file ~/haotian/datasets/ScienceQA/data/scienceqa/llava_test_QCM-LEA.json \ + --image-folder ~/haotian/datasets/ScienceQA/data/scienceqa/images/test \ + --answers-file ./test_llava-13b-chunk$CHUNKS_$IDX.jsonl \ + --num-chunks $CHUNKS \ + --chunk-idx $IDX \ + --conv-mode llava_v1 & +done diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/sqa_eval_gather.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/sqa_eval_gather.sh new file mode 100644 index 0000000000000000000000000000000000000000..525bd43b850e9f6a923158abd23bca6f8d15650e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/archived/sqa_eval_gather.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +CHUNKS=8 +output_file="test_llava-13b.jsonl" + +# Clear out the output file if it exists. +> "$output_file" + +# Loop through the indices and concatenate each file. +for idx in $(seq 0 $((CHUNKS-1))); do + cat "./test_llava-13b-chunk${idx}.jsonl" >> "$output_file" +done + +python llava/eval/eval_science_qa.py \ + --base-dir ~/haotian/datasets/ScienceQA/data/scienceqa \ + --result-file ./test_llava-13b.jsonl \ + --output-file ./test_llava-13b_output.json \ + --output-result ./test_llava-13b_result.json diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_all.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_all.sh new file mode 100644 index 0000000000000000000000000000000000000000..ee04c6ab8323f1a00d1fc821670106a91d11b786 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_all.sh @@ -0,0 +1,5 @@ + +# evaluate +./scripts/interleave/eval_interleave_3d.sh /path/to/ckpt /path/to/images multi_image_in_domain +./scripts/interleave/eval_interleave_3d.sh /path/to/ckpt /path/to/images multi_image_out_domain +./scripts/interleave/eval_interleave_3d.sh /path/to/ckpt /path/to/images multi_view_in_domain \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_interleave_3d.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_interleave_3d.sh new file mode 100644 index 0000000000000000000000000000000000000000..cea796cd72a57eedcca2b671b9f2cdd7572f47ab --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_interleave_3d.sh @@ -0,0 +1,28 @@ +alias python=python3 +CKPT_PATH=$1 +NAME=$(echo "$CKPT_PATH" | awk -F'/' '{print $NF}') +echo $NAME +##### set images path +DATA_PATH=$2 +EVAL_TYPE=$3 +JSON_PATH=$2/$3.json +############################### eval multi-image +RESULT_NAME="logs/${NAME}/${EVAL_TYPE}" +echo $RESULT_NAME + +mkdir -p logs/${NAME} + +file_path=${RESULT_NAME}/result.jsonl + +bash scripts/interleave/eval_multiprocess.sh \ +${CKPT_PATH} \ +${JSON_PATH} \ +${RESULT_NAME} \ +${DATA_PATH} \ +"" \ +8 0 + +python3 llava/eval/evaluate_interleave.py --result-dir ${RESULT_NAME} + + + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_multiprocess.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_multiprocess.sh new file mode 100644 index 0000000000000000000000000000000000000000..bab4f725e2873f363a5789ef69cd7cf19a116c92 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/interleave/eval_multiprocess.sh @@ -0,0 +1,54 @@ +#!/bin/bash + +# Check if three arguments are passed +if [ "$#" -ne 7 ]; then + echo "Usage: $0 " + exit 1 +fi + +# Assign the command line arguments to variables +model_path=$1 +question_path=$2 +base_answer_path=$3 +image_folder=$4 +extra_prompt=$5 +N=$6 +temperature=$7 + +# Loop over each chunk/process +for (( chunk_id=0; chunk_id "${base_answer_path}.jsonl" +for ((i=0; i> "${base_answer_path}/result.jsonl" +done +# remove the unmerged files +for (( chunk_id=0; chunk_id They are basically the same as the basic training scripts, but with some modifications, such as the data yaml. + +- `finetune_clip.sh`: This could be seen as the first image version LLaVA-NeXT (2024-01) training script, with `anyres` strategy and maximum 2x2 image grids. +- `finetune_siglip.sh`: Same but with `siglip` encoder, each grid becomes 729 tokens. +- `finetune_onevision.sh`: This is our latest training script, with `anyres_max_9` strategy and image grids weaving from 1x1 to 6x6, at most to 2304x2304 resolution. Inside the script, we also incorporate the multi-image and video data into training loop. the detail token strategy could be found in our paper. + +# About the LLaVA-OneVision Data + +We need to address the fact that our data has been collected and used in different projects/people. LLaVA-OneVision is our first attempt to integrate these datasets. For the data that has already been uploaded, we will refer you to the corresponding locations. We kindly ask everyone to gather the "fragments" and piece them together into a "diamond" in your own environment. + +Here we explain the some technical details on our data. + +- pretrain data - BLIP558K (same as previous llava 1.5 series) +- mid stage data mixture + ```yaml + datasets: + - json_path: /mnt/bn/vl-research/data/llava_instruct/blip558k_stage1.5_finetune_w_prompt.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/coco118k_stage1.5_finetune_w_prompt.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/cc3m_recap_data_prompt_v2.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_tr_sft.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/instruct_azure_dc_zh_92K.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/allava/Evol-Instruct-GPT4-Turbo-143K.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/synthdog_zh/synthdog_zh_100k.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/synthdog_en/synthdog_en_100k.json + sampling_strategy: all + ``` + The first three datasets can be collected via the [LLaVA-Recap](https://huggingface.co/collections/lmms-lab/llava-next-6623288e2d61edba3ddbf5ff) series data. We did a slightly modification to make the data more compatible to other data with an added prompt behind `` at each question. You may download our dataset and process it in local environment. Each data we added the **same prompt** "\nPlease generate detailed descriptions of the given image.". Here's an example: + ```json + { + "id": "000000000009", + "image": "coco/train2017/000000000009.jpg", + "conversations": [ + { + "from": "human", + "value": "\nPlease generate detailed descriptions of the given image." + }, + { + "from": "gpt", + "value": "The image shows a meal served in a blue tray with compartments. In the top left compartment, there is a slice of bread with a spread that appears to be butter, accompanied by a few almonds and a slice of what looks like a baked potato or sweet potato. The top right compartment contains a variety of fruits, including what seems to be pineapple, orange slices, and possibly a piece of melon.\n\nIn the bottom left compartment, there is a piece of bread with a spread that could be butter or margarine, and a small portion of what might be a meatball or a similar type of meat covered in a sauce. The bottom right compartment contains a serving of broccoli, which appears to be steamed or lightly cooked.\n\nThe meal is presented in a way that suggests it is a balanced meal, with a variety of food groups represented carbohydrates (bread), protein (meatball), healthy fats (almonds and butter), and fruits and vegetables (broccoli and the fruit assortment). The image is a close-up photograph with a focus on the food, and the colors are vibrant, indicating freshness." + } + ] + } + ``` + + The rest files are being uploaded to [LLaVA-OneVision Mid-Stage Data](https://huggingface.co/datasets/lmms-lab/LLaVA-OneVision-Mid-Data), except from `instruct_azure_dc_zh_92K` since it's internal data due and have policy issue (sad but I could preview one example). The `instruct_azure_dc_zh_92K` images are from COCO and QAs are generated by GPT-4V service provided by AzureAI. We uses this data in early stage experiments wishing to add Chinese knowledge to our model, and just kept using it (yes, just legacy, no other specific reason). + ```json + { + "id": "000000051920", + "image": "azure_dc_zh_92K/000000051920.jpg", + "conversations": [ + { + "from": "human", + "value": "\n这幅画中的关键信息有哪些？" + }, + { + "from": "gpt", + "value": "这张图片展示了一位穿着深色（可能是黑色或深蓝色）毛衣的人坐在一张桌子前，正在用右手拿着一片披萨。披萨看起来有多种配料，包括绿色的菠菜和橙红色的番茄，放在一个银色的圆形披萨盘上。披萨盘上还剩下大约六片披萨。在背景中，可以看到一个穿着浅色衣服的人站在柜台后面，柜台上方有一个黑板菜单，上面用白色粉笔写着菜单项，但是字迹不清晰，无法阅读。整个场景看起来像是在一个披萨店内部，环境显得比较休闲。" + } + ], + "data_source": "azure_dc_zh_92K" + } + ``` + +- single-image stage data mixture + +We have placed our single-image stage data in [single-image-yaml](https://github.com/LLaVA-VL/LLaVA-NeXT/blob/main/scripts/train/single_image.yaml) for users to review. You can download each subset from [onevision-data](https://huggingface.co/datasets/lmms-lab/LLaVA-OneVision-Data). + +Inside the data yaml, the first indicates the previous llava-1.6/next 790K data, you can download them in [llava-next-data](https://huggingface.co/datasets/lmms-lab/LLaVA-NeXT-Data). + +Inside the yaml, the naming would be different with our paper figure due to writing consideration. For users who need to explore our dataset, you can check the [upload script](https://github.com/LLaVA-VL/LLaVA-NeXT/blob/0070d0ae4931c9b19d9cc57c38e16a87c270a61c/playground/upload_data.py#L175) to find the mapping from our local dataset to HF's version. + +- onevision stage data mixture + +Our onevision stage data is available in [onevision-yaml](https://github.com/LLaVA-VL/LLaVA-NeXT/blob/main/scripts/train/onevision.yaml). The single-image portion can be downloaded from the above Huggingface link for onevision data. Here's a breakdown of each part: + + - Around 800K higher-quality data re-sampled from the previous stage (yes, it's data replay!). + - [M4-Instruct Data](https://huggingface.co/datasets/lmms-lab/M4-Instruct-Data) + - Video Data: We have released the video part along with [llava-video-data](https://huggingface.co/datasets/lmms-lab/LLaVA-Video-178K). Users can download the data, and we utilize the subset used in LLaVA-OneVision: + - We have included captions and open-ended questions in the 0_30_s_academic_v0_1 split, along with 240,000 open-ended QA items and 15,000 caption entries, as part of the video data in LLaVA-Hound for LLaVA-OneVision. + - 0_30_s_academic_v0_1 captions + - 0_30_s_academic_v0_1 open-ended QA + - LLaVA-Hound: Same as above. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/direct_finetune_clip.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/direct_finetune_clip.sh new file mode 100644 index 0000000000000000000000000000000000000000..ad246b413c4ae446056cc8a3c3c1c68d1f84ca31 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/direct_finetune_clip.sh @@ -0,0 +1,65 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="openai/clip-vit-large-patch14-336" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +PROMPT_VERSION="qwen_1_5" + +BASE_RUN_NAME="llavanext-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path ${LLM_VERSION} \ + --version ${PROMPT_VERSION} \ + --data_path=llava_1_6.json \ + --image_folder your_image_folder \ + --pretrain_mm_mlp_adapter="/checkpoints/projectors/${BASE_RUN_NAME}/mm_projector.bin" \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --mm_vision_tower_lr=2e-6 \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres \ + --image_grid_pinpoints "[(336, 672), (672, 336), (672, 672), (1008, 336), (336, 1008)]" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $MID_RUN_NAME \ + --output_dir "/checkpoints/${MID_RUN_NAME}" \ + --num_train_epochs 1 \ + --per_device_train_batch_size 4 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 3000 \ + --save_total_limit 1 \ + --learning_rate 1e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --attn_implementation sdpa + +# You can delete the sdpa attn_implementation if you want to use flash attn diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/direct_finetune_siglip_a4.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/direct_finetune_siglip_a4.sh new file mode 100644 index 0000000000000000000000000000000000000000..2a55cd914e2a5ed400689d11d756c5c2440f0ef6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/direct_finetune_siglip_a4.sh @@ -0,0 +1,67 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +PROMPT_VERSION="qwen_1_5" + +BASE_RUN_NAME="llavanext-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +CKPT_PATH=$LLM_VERSION # this could also be the previous stage checkpoint + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path ${CKPT_PATH} \ + --version ${PROMPT_VERSION} \ + --data_path=llava_1_6.json \ + --image_folder your_image_folder \ + --pretrain_mm_mlp_adapter="/checkpoints/projectors/${BASE_RUN_NAME}/mm_projector.bin" \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --mm_vision_tower_lr=2e-6 \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres \ + --image_grid_pinpoints "[(384, 768), (768, 384), (768, 768), (1152, 384), (384, 1152)]" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $MID_RUN_NAME \ + --output_dir "/checkpoints/${MID_RUN_NAME}" \ + --num_train_epochs 1 \ + --per_device_train_batch_size 4 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 3000 \ + --save_total_limit 1 \ + --learning_rate 1e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --attn_implementation sdpa + +# You can delete the sdpa attn_implementation if you want to use flash attn diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/dpo.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/dpo.sh new file mode 100644 index 0000000000000000000000000000000000000000..83bfe84121e56ed615f450305da39822b780b667 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/dpo.sh @@ -0,0 +1,64 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +# export NCCL_IB_HCA=${ARNOLD_RDMA_DEVICE} +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +VISION_MODEL_VERSION="openai/clip-vit-large-patch14-336" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +# Stage 2 +PROMPT_VERSION="qwen_1_5" + +#torchrun --nproc_per_node="${ARNOLD_WORKER_GPU}" --nnodes="${ARNOLD_WORKER_NUM}" --node_rank="${ARNOLD_ID}" --master_addr="${METIS_WORKER_0_HOST}" --master_port="${port_in_cmd}" \ +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${ARNOLD_WORKER_GPU}" --nnodes="${ARNOLD_WORKER_NUM}" --node_rank="${ARNOLD_ID}" --master_addr="${METIS_WORKER_0_HOST}" --master_port="${port_in_cmd}" \ + llava/train/train_dpo.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path lmms-lab/LongVA-7B \ + --version $PROMPT_VERSION \ + --dpo_alpha 1.0 --beta 0.1 --gamma 0 \ + --data_path="/data/llava_video/shareVideoGPTV/dpo/sft_dpo_17k.jsonl" \ + --image_folder /data/llava_data \ + --video_folder /llava_video/shareVideoGPTV/frames/all_frames/ \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --mm_spatial_pool_stride 2 \ + --mm_resampler_type "spatial_pool" \ + --mm_spatial_pool_out_channels 1024 \ + --group_by_modality_length True \ + --image_aspect_ratio anyres \ + --image_grid_pinpoints "[(336, 672), (672, 336), (672, 672), (1008, 336), (336, 1008)]" \ + --mm_patch_merge_type unires \ + --bf16 True \ + --run_name $MID_RUN_NAME \ + --output_dir "/checkpoints/${MID_RUN_NAME}" \ + --num_train_epochs 3 \ + --per_device_train_batch_size 1 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 16 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 3000 \ + --save_total_limit 1 \ + --learning_rate 5e-7 \ + --weight_decay 0. \ + --warmup_ratio 0.1 \ + --lr_scheduler_type "linear" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --attn_implementation sdpa \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/dpo_ov7b.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/dpo_ov7b.sh new file mode 100644 index 0000000000000000000000000000000000000000..26748e4b1710ec41ab88eb455933a238a439faf5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/dpo_ov7b.sh @@ -0,0 +1,69 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +# export NCCL_IB_HCA=${ARNOLD_RDMA_DEVICE} +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +# DPO Stage +PROMPT_VERSION="qwen_1_5" +SFT_MODEL="lmms-lab/llava-onevision-qwen2-7b-ov" +EPOCH=1 +beta=0.1 + +DPO_RUN_NAME="llava-onevision-qwen2-7b-ov_dpo-beta${beta}-epoch${EPOCH}" +DPO_CLEAN_NAME="${DPO_RUN_NAME##*/}" +OUTPUT_DIR="/${DPO_CLEAN_NAME}" +DATA_PATH="" + +echo $DPO_RUN_NAME + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_dpo.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path=${SFT_MODEL} \ + --dpo_alpha=1.0 \ + --beta=${beta} \ + --gamma=0 \ + --version $PROMPT_VERSION \ + --data_path=$DATA_PATH \ + --image_folder "" \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --unfreeze_mm_vision_tower True \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres_max_9 \ + --image_grid_pinpoints "(1x1),...,(6x6)" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $DPO_CLEAN_NAME \ + --output_dir $OUTPUT_DIR \ + --num_train_epochs $EPOCH \ + --per_device_train_batch_size 1 \ + --per_device_eval_batch_size 1 \ + --gradient_accumulation_steps 8 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 1000 \ + --save_total_limit 1 \ + --learning_rate 5e-7 \ + --weight_decay 0. \ + --warmup_ratio 0.1 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 4 \ + --lazy_preprocess True \ + --report_to wandb \ + --dataloader_drop_last True + + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/finetune_ov.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/finetune_ov.sh new file mode 100644 index 0000000000000000000000000000000000000000..0a4526684481f3dec5cc987ac4c8e989c4d62994 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/finetune_ov.sh @@ -0,0 +1,75 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +# for 7b model we recommend bs=1, accum=2, 16 nodes, 128 gpus, lr=1e-5, warmup=0.03 +# for 72b model we recommend bs=1, accum=1, 32 nodes, 256 gpus, lr=1e-5, warmup=0.03 +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +BASE_RUN_NAME="llavanext-google_siglip-so400m-patch14-384-Qwen_Qwen2-7B-Instruct-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +############### Finetune ################ + +# Stage 2 +PROMPT_VERSION="qwen_1_5" +RUN_NAME="llava-onevision-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-ov_stage_am9" +PREV_STAGE_CHECKPOINT="/mnt/bn/vl-research/checkpoints/onevision/llavanext-google_siglip-so400m-patch14-384-Qwen_Qwen2-7B-Instruct-mid_to_final_next_3m_am9_july14" # replace it with your last checkpoint training from single image collection +echo "PREV_STAGE_CHECKPOINT: ${PREV_STAGE_CHECKPOINT}" +echo "MID_RUN_NAME: ${RUN_NAME}" + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path $PREV_STAGE_CHECKPOINT \ + --version $PROMPT_VERSION \ + --data_path /mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next/scripts/i18n/scale_llms/next_ov_stage_july21.yaml \ + --image_folder /mnt/bn/vl-research/data/llava_data \ + --video_folder /mnt/bn/vl-research/data/llava_video \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --mm_vision_tower_lr=2e-6 \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres_max_9 \ + --image_grid_pinpoints "(1x1),...,(6x6)" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $RUN_NAME \ + --output_dir /mnt/bn/vl-research/checkpoints/onevision/$RUN_NAME \ + --num_train_epochs 1 \ + --per_device_train_batch_size 1 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 2 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 1000 \ + --save_total_limit 1 \ + --learning_rate 1e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 4 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --frames_upbound 32 +exit 0; + +# You can delete the sdpa attn_implementation if you want to use flash attn diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/finetune_si.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/finetune_si.sh new file mode 100644 index 0000000000000000000000000000000000000000..32768f30647be88c331532d17c08dcdca7c1c989 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/finetune_si.sh @@ -0,0 +1,73 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +# for 7b model we recommend bs=1, accum=2, 16 nodes, 128 gpus, lr=1e-5, warmup=0.03 +# for 72b model we recommend bs=1, accum=1, 32 nodes, 256 gpus, lr=1e-5, warmup=0.03 +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +BASE_RUN_NAME="llavanext-google_siglip-so400m-patch14-384-Qwen_Qwen2-7B-Instruct-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +############### Finetune ################ + +# Stage 2 +PROMPT_VERSION="qwen_1_5" +RUN_NAME="llava-onevision-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-si_stage_am9" +PREV_STAGE_CHECKPOINT="/mnt/bn/vl-research/checkpoints/onevision/xxxxxxxxxxxxxxxx" # replace it with your last checkpoint training from mid stage +echo "PREV_STAGE_CHECKPOINT: ${PREV_STAGE_CHECKPOINT}" +echo "MID_RUN_NAME: ${RUN_NAME}" + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path $PREV_STAGE_CHECKPOINT \ + --version $PROMPT_VERSION \ + --data_path /mnt/bn/vl-research/workspace/boli01/projects/LLaVA_Next/scripts/i18n/scale_llms/next_3p2m_single_image.yaml \ + --image_folder /mnt/bn/vl-research/data/llava_data \ + --video_folder /mnt/bn/vl-research/data/llava_video \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --mm_vision_tower_lr=2e-6 \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres_max_9 \ + --image_grid_pinpoints "(1x1),...,(6x6)" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $RUN_NAME \ + --output_dir /mnt/bn/vl-research/checkpoints/onevision/$RUN_NAME \ + --num_train_epochs 1 \ + --per_device_train_batch_size 1 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 2 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 1000 \ + --save_total_limit 1 \ + --learning_rate 1e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 4 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --frames_upbound 32 +exit 0; diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/mid_stage.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/mid_stage.yaml new file mode 100644 index 0000000000000000000000000000000000000000..566998719fdeb3837e097da88014db56f380fd66 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/mid_stage.yaml @@ -0,0 +1,17 @@ +datasets: + - json_path: /mnt/bn/vl-research/data/llava_instruct/blip558k_stage1.5_finetune_w_prompt.json # released in lmms-lab/LLaVA-ReCap-* + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/coco118k_stage1.5_finetune_w_prompt.json # released in lmms-lab/LLaVA-ReCap-* + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/cc3m_recap_data_prompt_v2.json # released in lmms-lab/LLaVA-ReCap-* + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_tr_sft.json # released in lmms-lab/LLaVA-OneVision-Mid-Data + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/instruct_azure_dc_zh_92K.json # not released, explained at https://github.com/LLaVA-VL/LLaVA-NeXT/tree/main/scripts/train + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/Evol-Instruct-GPT4-Turbo-143K.json # released in lmms-lab/LLaVA-OneVision-Mid-Data + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/synthdog_zh/synthdog_zh_100k.json # released in lmms-lab/LLaVA-OneVision-Mid-Data + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/synthdog_en/synthdog_en_100k.json # released in lmms-lab/LLaVA-OneVision-Mid-Data + sampling_strategy: all \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/onevision.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/onevision.yaml new file mode 100644 index 0000000000000000000000000000000000000000..117a5e8f97ebf64840a5bbd4b2edf2acf100a617 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/onevision.yaml @@ -0,0 +1,185 @@ +datasets: + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_next_fit_mix_filtered_text_wild_738590.json + sampling_strategy: "first:50%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_wild_4v_39k.json # not released + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_wild_4v_12k.json # not released + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_metagen_87358.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_rule_geo_100000.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/cambrian_filtered_gpt4vo_sp_token_fltd_max10k_checked.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/VisualWebInstruct_filtered_263589.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/visual_chat_en_26048_gpt4o_coco_checked.json # not released + sampling_strategy: "all" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/gpt4o_combinations_51316.json + # sampling_strategy: "all" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/chrome_writting_train_8835.json + # sampling_strategy: "first:20%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/k12_printing_train_256646.json + # sampling_strategy: "first:1%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/iiit5k_annotations_2000.json + # sampling_strategy: "first:20%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/hme100k_train_clean_74502.json + # sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sroie_data_33626.json + # sampling_strategy: "first:1%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/orand_car_a_train_2009.json + # sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/orand_car_b_train_3000.json + # sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llavar_gpt4_20k.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_azuregpt_detailed_understanding_4874.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_vqa_4404.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_azuregpt4v_1992.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_chart_1787.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_normal_gpt4v_filtered_10500.json + sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/scienceqa_nona_context_19218.json + # sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_vflan4v_20000.json + sampling_strategy: "first:30%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_laion4v_50000.json + sampling_strategy: "first:30%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textocr_gpt4v_train_converted_25114.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_train_internvl_single_12413.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textcaps_train_21952.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_qa_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_cap_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_ie_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_kg_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/vision_flan_filtered_186070.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mathqa_29837.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo3k_2101.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_qa_converted_67833.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_align_converted_60252.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4o_dataset.jsonl + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-coco-50k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-knowledge-2k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-llava-30k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-sam-20k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_CLEVR-Math_5290.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_FigureQA_17597.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Geometry3K_9734.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GeoQA+_17172.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GEOS_508.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_IconQA_22599.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_MapQA_5235.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_PlotQA_5485.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_PMC-VQA_35958.json + sampling_strategy: "first:1%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Super-CLEVR_8652.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TabMWP_22462.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TQA_10181.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_UniGeo_11959.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VizWiz_6614.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VQA-AS_5907.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VQA-RAD_2130.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_qwen2_72b_st_300000_sp_token_fltd_299992.json + sampling_strategy: "end:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_st_300000.json + sampling_strategy: "end:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_mt_300000_sp_token_fltd_299998.json + sampling_strategy: "end:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/image_textualization_dataset_filtered.json + sampling_strategy: "first:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/ai2d_llava_format_2434.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/chart2text_26961.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/chartqa_18265_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/diagram_image_to_text_300.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/hateful_memes_8500_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/hitab_2500_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/iam_5663.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/infographic_vqa_2118_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/intergps_1280_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/mapqa_37417_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/rendered_text_10000.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_sqa_8514.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wikisql_74989.json + sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wtq_38246_llava_format_filtered_4000tokens_38236.json + # sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/screen2words_15730.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tabmwp_22722.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tallyqa_98680_llava_format.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/st_vqa_17247_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tqa_llava_format_27307.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/visual7w_llava_format_14366.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/visualmrc_3027.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vqarad_313_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vsr_2157_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vistext_9969.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/websight_10000.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_ofa_DEMON-FULL_filtered_311085.json # released in lmms-lab/M4-Instruct + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_ofa_mantis-instruct_reformatted.json # released in lmms-lab/M4-Instruct + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/academic_source_30s_v1_all.json # will be released in next version of LLaVA-NeXT-Video + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/0718_0_30_s_academic_mc_v0_1_all.json # will be released in next version of LLaVA-NeXT-Video + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4video_255000.json # download from sharegpt4video + sampling_strategy: all diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/pretrain_clip.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/pretrain_clip.sh new file mode 100644 index 0000000000000000000000000000000000000000..2eb5c27e686ba69a486bd78312b08802fbb7130e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/pretrain_clip.sh @@ -0,0 +1,55 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="openai/clip-vit-large-patch14-336" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +PROMPT_VERSION=plain + +BASE_RUN_NAME="llavanext-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path ${LLM_VERSION} \ + --version ${PROMPT_VERSION} \ + --data_path /blip_558k/blip_558k_plain.json \ + --image_folder /blip_558k/images \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_tunable_parts="mm_mlp_adapter" \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir /checkpoints/projectors/${BASE_RUN_NAME} \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "no" \ + --save_steps 50000 \ + --learning_rate 1e-3 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 8192 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb \ + --run_name $BASE_RUN_NAME \ + --attn_implementation sdpa + +# You can delete the sdpa attn_implementation if you want to use flash attn \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/pretrain_siglip.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/pretrain_siglip.sh new file mode 100644 index 0000000000000000000000000000000000000000..ef13793d1c499ae6aac27dfd66193b14a9e69d19 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/pretrain_siglip.sh @@ -0,0 +1,55 @@ +export OMP_NUM_THREADS=8 +export NCCL_IB_DISABLE=0 +export NCCL_IB_GID_INDEX=3 +export NCCL_SOCKET_IFNAME=eth0 +export NCCL_DEBUG=INFO + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + +############### Pretrain ################ + +PROMPT_VERSION=plain + +BASE_RUN_NAME="llavanext-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${NUM_GPUS}" --nnodes="${NNODES}" --node_rank="${RANK}" --master_addr="${ADDR}" --master_port="${PORT}" \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path ${LLM_VERSION} \ + --version ${PROMPT_VERSION} \ + --data_path /blip_558k/blip_558k_plain.json \ + --image_folder /blip_558k/images \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_tunable_parts="mm_mlp_adapter" \ + --mm_vision_select_layer -2 \ + --mm_projector_type mlp2x_gelu \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --bf16 True \ + --output_dir /checkpoints/projectors/${BASE_RUN_NAME} \ + --num_train_epochs 1 \ + --per_device_train_batch_size 16 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 1 \ + --evaluation_strategy "no" \ + --save_strategy "no" \ + --save_steps 50000 \ + --learning_rate 1e-3 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 8192 \ + --gradient_checkpointing True \ + --dataloader_num_workers 16 \ + --lazy_preprocess True \ + --report_to wandb \ + --run_name $BASE_RUN_NAME \ + --attn_implementation sdpa + +# You can delete the sdpa attn_implementation if you want to use flash attn \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/single_image.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/single_image.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a21e3a159389add74737e53c23b851d8163972c3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/train/single_image.yaml @@ -0,0 +1,187 @@ +datasets: + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_next_fit_mix_filtered_text_wild_738590.json # released in lmms-lab/LLaVA-NeXT-Data + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_wild_4v_39k.json # not released + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_wild_4v_12k.json # not released + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llavar_gpt4_20k.json + sampling_strategy: "all" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sroie_data_33626.json + # sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/orand_car_a_train_2009.json + # sampling_strategy: "all" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/orand_car_b_train_3000.json + # sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_metagen_87358.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_rule_geo_100000.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/chrome_writting_train_8835.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/k12_printing_train_256646.json + sampling_strategy: "first:1%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/iiit5k_annotations_2000.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/hme100k_train_clean_74502.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_azuregpt_detailed_understanding_4874.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_vqa_4404.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_azuregpt4v_1992.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_chart_1787.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_normal_gpt4v_filtered_10500.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/scienceqa_nona_context_19218.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_vflan4v_20000.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_laion4v_50000.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textocr_gpt4v_train_converted_25114.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_train_internvl_single_12413.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textcaps_train_21952.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_qa_sft.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_cap_sft.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_ie_sft.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_kg_sft.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/vision_flan_filtered_186070.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mathqa_29837.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo3k_2101.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_qa_converted_67833.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_align_converted_60252.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-coco-50k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-knowledge-2k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-llava-30k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-sam-20k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_CLEVR-Math_5290.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_FigureQA_17597.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Geometry3K_9734.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GeoQA+_17172.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GEOS_508.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_IconQA_22599.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_MapQA_5235.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_PMC-VQA_35958.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Super-CLEVR_8652.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TabMWP_22462.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TQA_10181.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_UniGeo_11959.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VizWiz_6614.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VQA-AS_5907.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VQA-RAD_2130.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/Evol-Instruct-GPT4-Turbo-143000.json + sampling_strategy: "first:30%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_qwen2_72b_st_300000_sp_token_fltd_299992.json + sampling_strategy: "first:50%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_st_300000.json + sampling_strategy: "first:50%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_mt_300000_sp_token_fltd_299998.json + sampling_strategy: "first:50%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/image_textualization_dataset_filtered.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/cambrian_filtered_gpt4vo_sp_token_fltd_max10k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4o_dataset.jsonl + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/ai2d_llava_format_2434.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/aokvqa_16539_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/chart2text_26961.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/chartqa_18265_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/clevr_70000_llava_format.json + sampling_strategy: "first:1%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/diagram_image_to_text_300.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/dvqa_200000_llava_format.json + sampling_strategy: "first:1%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/figureqa_100000_llava_format.json + sampling_strategy: "first:1%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/geomverse_9303.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/hateful_memes_8500_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/hitab_2500_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/iam_5663.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/raven_42000.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/iconqa_llava_format_27307.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/infographic_vqa_2118_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/intergps_1280_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/mapqa_37417_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/multihiertt_7619.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/rendered_text_10000.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_sqa_8514.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wikisql_74989.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wtq_38246_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/screen2words_15730.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/scienceqa_llava_format_4976.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tabmwp_22722.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tallyqa_98680_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/st_vqa_17247_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tqa_llava_format_27307.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/visual7w_llava_format_14366.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/visualmrc_3027.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vqarad_313_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vsr_2157_llava_format.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vistext_9969.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/websight_10000.json + sampling_strategy: "all" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/demo/video_demo.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/demo/video_demo.sh new file mode 100644 index 0000000000000000000000000000000000000000..17f24c957617793ca7f8edad7d01d6dc55f4268d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/demo/video_demo.sh @@ -0,0 +1,43 @@ +#!/bin/bash +ROOT_DIR="/mnt/bn/vl-research/workspace/yhzhang/LLaVA-NeXT" + +if [ ! -e $ROOT_DIR ]; then + echo "The root dir does not exist. Exiting the script." + exit 1 +fi + +cd $ROOT_DIR + +export PYTHONWARNINGS=ignore +export TOKENIZERS_PARALLELISM=false + +CKPT=$1 +CONV_MODE=$2 +FRAMES=$3 +POOL_STRIDE=$4 +POOL_MODE=$5 +NEWLINE_POSITION=$6 +OVERWRITE=$7 +VIDEO_PATH=$8 + + +if [ "$OVERWRITE" = False ]; then + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE}_overwrite_${OVERWRITE} + +else + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE} +fi + +python3 playground/demo/video_demo.py \ + --model-path $CKPT \ + --video_path ${VIDEO_PATH} \ + --output_dir ./work_dirs/video_demo/$SAVE_DIR \ + --output_name pred \ + --chunk-idx $(($IDX - 1)) \ + --overwrite ${OVERWRITE} \ + --mm_spatial_pool_stride ${POOL_STRIDE:-4} \ + --for_get_frames_num $FRAMES \ + --conv-mode $CONV_MODE \ + --mm_spatial_pool_mode ${POOL_MODE:-average} \ + --mm_newline_position ${NEWLINE_POSITION:-grid} \ + --prompt "Please provide a detailed description of the video, focusing on the main subjects, their actions, the background scenes." \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/activitynet_eval.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/activitynet_eval.sh new file mode 100644 index 0000000000000000000000000000000000000000..6e16c5a5d53222695abdc9a44de0dd153fab8c37 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/activitynet_eval.sh @@ -0,0 +1,96 @@ +#!/bin/bash +ROOT_DIR="root to LLaVA-NeXT-Video" + +if [ ! -e $ROOT_DIR ]; then + echo "The root dir does not exist. Exiting the script." + exit 1 +fi + +cd $ROOT_DIR + +export PYTHONWARNINGS=ignore +export TOKENIZERS_PARALLELISM=false +CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7' +gpu_list="${CUDA_VISIBLE_DEVICES}" +GPULIST=(${(s:,:)gpu_list}) + +CHUNKS=${#GPULIST[@]} +echo "Using $CHUNKS GPUs" + +CKPT=$1 +CONV_MODE=$2 +FRAMES=$3 +OVERWRITE=$4 +PREDEFINED_CONFIGURE=$5 +mm_spatial_pool_stride=$6 +MODEL_MAX_LENGTH=${7:-0} + +CKPT=$1 +CONV_MODE=$2 +FRAMES=$3 +POOL_STRIDE=$4 +OVERWRITE=$5 +CHUNKS=${6:-1} + +PATCHIFY=False + + +OPENAIKEY="INPUT YOUR OPENAI API" + + +if [ "$OVERWRITE" = False ]; then + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE}_overwrite_${OVERWRITE} + +else + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE} +fi + +echo $SAVE_DIR + +# for IDX in {1..$CHUNKS}; do +# GPU_ID=${GPULIST[$IDX]} # Note: Zsh arrays are 1-indexed by default + +# # GPU_FREE=0 +# # while [ $GPU_FREE -eq 0 ]; do +# # # Using nvidia-smi to get the memory usage of the GPU with ID $GPU_ID +# # # Parsing the output to extract the memory usage, and checking if it is "0" +# # MEM_USAGE=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i $GPU_ID | tr -d '[:space:]') + +# # if [ "$MEM_USAGE" -eq 0 ]; then +# # GPU_FREE=1 +# # echo "GPU $GPU_ID is free." +# # else +# # echo "GPU $GPU_ID is in use. Memory used: ${MEM_USAGE}MiB. Checking again in 100 seconds..." +# # sleep 100 +# # fi +# # done + +# echo "Running on GPU $GPU_ID" +# CUDA_VISIBLE_DEVICES=$GPU_ID python3 llavavid/eval/model_activitynet_qa.py \ +# --model-path $CKPT \ +# --video_dir ./data/llava_video/ActivityNet-QA/all_test \ +# --gt_file_question ./data/llava_video/ActivityNet-QA/test_q.json \ +# --gt_file_answers ./data/llava_videoActivityNet-QA/test_a.json \ +# --output_dir ./work_dirs/eval_activitynet/$SAVE_DIR \ +# --output_name pred \ +# --num-chunks $CHUNKS \ +# --chunk-idx $(($IDX - 1)) \ +# --overwrite ${OVERWRITE} \ +# --patchify_video_feature ${PATCHIFY} \ +# --predefined_configure ${PREDEFINED_CONFIGURE} \ +# --mm_spatial_pool_stride ${mm_spatial_pool_stride:-4} \ +# --for_get_frames_num $FRAMES \ +# --model-max-length ${MODEL_MAX_LENGTH:-0} \ +# --conv-mode $CONV_MODE & + +# done + +# wait + +python3 llava/eval/eval_activitynet_qa.py \ + --pred_path ./work_dirs/eval_activitynet/$SAVE_DIR \ + --output_dir ./work_dirs/eval_activitynet/$SAVE_DIR/results \ + --output_json ./work_dirs/eval_activitynet/$SAVE_DIR/results.json \ + --num_chunks $CHUNKS \ + --api_key $OPENAIKEY \ + # --num_tasks 16 \ \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_chatgpt_benchmark_eval_shard.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_chatgpt_benchmark_eval_shard.sh new file mode 100644 index 0000000000000000000000000000000000000000..8b6518a2da0f3735714a90698175e9504734b7d8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_chatgpt_benchmark_eval_shard.sh @@ -0,0 +1,242 @@ +#!/bin/bash +ROOT_DIR="root to LLaVA-NeXT-Video" + +if [ ! -e $ROOT_DIR ]; then + echo "The root dir does not exist. Exiting the script." + exit 1 +fi + +cd $ROOT_DIR + +export python3WARNINGS=ignore +export TOKENIZERS_PARALLELISM=false +# CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7' +gpu_list="${CUDA_VISIBLE_DEVICES}" +GPULIST=(${(s:,:)gpu_list}) + +# CHUNKS=${#GPULIST[@]} +# echo "Using $CHUNKS GPUs" + +CKPT=$1 +CONV_MODE=$2 +FRAMES=$3 +POOL_STRIDE=$4 +OVERWRITE=$5 +CHUNKS=${6:-1} + +OPENAIKEY="INPUT YOUR OPENAI API" + +if [ "$OVERWRITE" = False ]; then + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE}_overwrite_${OVERWRITE} + +else + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE} +fi + +echo $SAVE_DIR + +# Assuming GPULIST is a bash array containing your GPUs +GPULIST=(0 1 2 3 4 5 6 7) + +# Get the number of GPUs +NUM_GPUS=${#GPULIST[@]} + +# Calculate GPUs per chunk +GPUS_PER_CHUNK=$((NUM_GPUS / CHUNKS)) + + +for IDX in $(seq 1 $CHUNKS); do + START=$(((IDX-1) * GPUS_PER_CHUNK)) + LENGTH=$GPUS_PER_CHUNK # Length for slicing, not the end index + + CHUNK_GPUS=(${GPULIST[@]:$START:$LENGTH}) + + # Convert the chunk GPUs array to a comma-separated string + CHUNK_GPUS_STR=$(IFS=,; echo "${CHUNK_GPUS[*]}") + + # ALL_GPUS_FREE=0 + # while [ $ALL_GPUS_FREE -eq 0 ]; do + # ALL_GPUS_FREE=1 # Assume all GPUs are free initially + + # for GPU_ID in $CHUNK_GPUS; do + # MEM_USAGE=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i $GPU_ID | tr -d '[:space:]') + + # # Assuming a GPU is considered free if its memory usage is less than 100 MiB + # if [ "$MEM_USAGE" -ge 100 ]; then + # ALL_GPUS_FREE=0 + # echo "GPU $GPU_ID is in use. Memory used: ${MEM_USAGE}MiB." + # break # Exit the loop early as we found a GPU that is not free + # fi + # done + + # if [ $ALL_GPUS_FREE -eq 0 ]; then + # echo "Not all GPUs in chunk are free. Checking again in 100 seconds..." + # sleep 100 + # fi + # done + + echo "CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR" + CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR python3 llava/eval/model_video_chatgpt_general.py \ + --model-path $CKPT \ + --video_dir ./data/llava_video/video-chatgpt/evaluation/Test_Videos/ \ + --gt_file ./data/llava_video/video-chatgpt/evaluation/generic_qa.json \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_name pred \ + --num-chunks $CHUNKS \ + --chunk-idx $(($IDX - 1)) \ + --overwrite ${OVERWRITE:-true} \ + --mm_spatial_pool_stride ${POOL_STRIDE:-4} \ + --for_get_frames_num $FRAMES \ + --conv-mode $CONV_MODE & +done + +wait + +python3 llava/eval/evaluate_benchmark_1_correctness.py \ + --pred_path ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR/correctness_results \ + --output_json ./work_dirs/eval_video_chatgpt/$SAVE_DIR/correctness_results.json \ + --num_chunks $CHUNKS \ + --output_name pred \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ + + +python3 llava/eval/evaluate_benchmark_2_detailed_orientation.py \ + --pred_path ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR/detail_results \ + --output_json ./work_dirs/eval_video_chatgpt/$SAVE_DIR/detail_results.json \ + --num_chunks $CHUNKS \ + --output_name pred \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ + + +python3 llava/eval/evaluate_benchmark_3_context.py \ + --pred_path ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR/context_results \ + --output_json ./work_dirs/eval_video_chatgpt/$SAVE_DIR/context_results.json \ + --num_chunks $CHUNKS \ + --output_name pred \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ + + + +for IDX in $(seq 1 $CHUNKS); do + START=$(((IDX-1) * GPUS_PER_CHUNK)) + LENGTH=$GPUS_PER_CHUNK # Length for slicing, not the end index + + CHUNK_GPUS=(${GPULIST[@]:$START:$LENGTH}) + + # Convert the chunk GPUs array to a comma-separated string + CHUNK_GPUS_STR=$(IFS=,; echo "${CHUNK_GPUS[*]}") + + # ALL_GPUS_FREE=0 + # while [ $ALL_GPUS_FREE -eq 0 ]; do + # ALL_GPUS_FREE=1 # Assume all GPUs are free initially + + # for GPU_ID in $CHUNK_GPUS; do + # MEM_USAGE=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i $GPU_ID | tr -d '[:space:]') + + # # Assuming a GPU is considered free if its memory usage is less than 100 MiB + # if [ "$MEM_USAGE" -ge 100 ]; then + # ALL_GPUS_FREE=0 + # echo "GPU $GPU_ID is in use. Memory used: ${MEM_USAGE}MiB." + # break # Exit the loop early as we found a GPU that is not free + # fi + # done + + # if [ $ALL_GPUS_FREE -eq 0 ]; then + # echo "Not all GPUs in chunk are free. Checking again in 100 seconds..." + # sleep 100 + # fi + # done + + echo "CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR" + CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR python3 llava/eval/model_video_chatgpt_general.py \ + --model-path $CKPT \ + --video_dir ./data/llava_video/video-chatgpt/evaluation/Test_Videos/ \ + --gt_file ./data/llava_video/video-chatgpt/evaluation/temporal_qa.json \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_name pred_temporal \ + --num-chunks $CHUNKS \ + --chunk-idx $(($IDX - 1)) \ + --for_get_frames_num $FRAMES \ + --overwrite ${OVERWRITE} \ + --mm_spatial_pool_stride ${POOL_STRIDE:-4} \ + --conv-mode $CONV_MODE & + +done + +wait + + +python3 llava/eval/evaluate_benchmark_4_temporal.py \ + --pred_path ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR/temporal_results \ + --output_json ./work_dirs/eval_video_chatgpt/$SAVE_DIR/temporal_results.json \ + --num_chunks $CHUNKS \ + --output_name pred_temporal \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ + + + +for IDX in $(seq 1 $CHUNKS); do + START=$(((IDX-1) * GPUS_PER_CHUNK)) + LENGTH=$GPUS_PER_CHUNK # Length for slicing, not the end index + + CHUNK_GPUS=(${GPULIST[@]:$START:$LENGTH}) + + # Convert the chunk GPUs array to a comma-separated string + CHUNK_GPUS_STR=$(IFS=,; echo "${CHUNK_GPUS[*]}") + + # ALL_GPUS_FREE=0 + # while [ $ALL_GPUS_FREE -eq 0 ]; do + # ALL_GPUS_FREE=1 # Assume all GPUs are free initially + + # for GPU_ID in $CHUNK_GPUS; do + # MEM_USAGE=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i $GPU_ID | tr -d '[:space:]') + + # # Assuming a GPU is considered free if its memory usage is less than 100 MiB + # if [ "$MEM_USAGE" -ge 100 ]; then + # ALL_GPUS_FREE=0 + # echo "GPU $GPU_ID is in use. Memory used: ${MEM_USAGE}MiB." + # break # Exit the loop early as we found a GPU that is not free + # fi + # done + + # if [ $ALL_GPUS_FREE -eq 0 ]; then + # echo "Not all GPUs in chunk are free. Checking again in 100 seconds..." + # sleep 100 + # fi + # done + + echo "CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR" + CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR python3 llava/eval/model_video_chatgpt_consistency.py \ + --model-path $CKPT \ + --video_dir ./data/llava_video/video-chatgpt/evaluation/Test_Videos/ \ + --gt_file ./data/llava_video/video-chatgpt/evaluation/consistency_qa.json \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_name pred_consistency \ + --num-chunks $CHUNKS \ + --chunk-idx $(($IDX - 1)) \ + --mm_spatial_pool_stride ${POOL_STRIDE:-4} \ + --for_get_frames_num $FRAMES \ + --overwrite ${OVERWRITE} \ + --conv-mode $CONV_MODE & +done + +wait + + +python3 llava/eval/evaluate_benchmark_5_consistency.py \ + --pred_path ./work_dirs/eval_video_chatgpt/$SAVE_DIR \ + --output_dir ./work_dirs/eval_video_chatgpt/$SAVE_DIR/consistency_results \ + --output_json ./work_dirs/eval_video_chatgpt/$SAVE_DIR/consistency_results.json \ + --num_chunks $CHUNKS \ + --output_name pred_consistency \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_description_from_t2v.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_description_from_t2v.sh new file mode 100644 index 0000000000000000000000000000000000000000..7b87c9408acc9cb33f74f2792055c4de565534d4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_description_from_t2v.sh @@ -0,0 +1,98 @@ +#!/bin/bash +ROOT_DIR="/mnt/bn/vl-research/workspace/yhzhang/llava-next-video" + +if [ ! -e $ROOT_DIR ]; then + echo "The root dir does not exist. Exiting the script." + exit 1 +fi + +cd $ROOT_DIR + +export PYTHONWARNINGS=ignore +export TOKENIZERS_PARALLELISM=false + +CKPT=$1 +CONV_MODE=$2 +FRAMES=$3 +POOL_STRIDE=$4 +OVERWRITE=$5 +CHUNKS=${6:-1} +DO_CENTER_CROP=${7:-False} + +echo "Using $CHUNKS GPUs" + +LOAD_8BIT=False + + +if [ "$OVERWRITE" = False ]; then + if [ "$MODEL_MAX_LENGTH" = 0 ]; then + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_overwrite_${OVERWRITE} + else + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_overwrite_${OVERWRITE} + fi +else + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE} +fi + +SAVE_DIR=${SAVE_DIR}_do_center_crop_${DO_CENTER_CROP} +# Assuming GPULIST is a bash array containing your GPUs +GPULIST=(0 1 2 3 4 5 6 7) +# GPULIST=(0) + +# Get the number of GPUs +NUM_GPUS=${#GPULIST[@]} + +# Calculate GPUs per chunk +GPUS_PER_CHUNK=$((NUM_GPUS / CHUNKS)) + + +for IDX in $(seq 1 $CHUNKS); do + START=$(((IDX-1) * GPUS_PER_CHUNK)) + LENGTH=$GPUS_PER_CHUNK # Length for slicing, not the end index + + CHUNK_GPUS=(${GPULIST[@]:$START:$LENGTH}) + + # Convert the chunk GPUs array to a comma-separated string + CHUNK_GPUS_STR=$(IFS=,; echo "${CHUNK_GPUS[*]}") + + # ALL_GPUS_FREE=0 + # while [ $ALL_GPUS_FREE -eq 0 ]; do + # ALL_GPUS_FREE=1 # Assume all GPUs are free initially + + # for GPU_ID in $CHUNK_GPUS; do + # MEM_USAGE=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i $GPU_ID | tr -d '[:space:]') + + # # Assuming a GPU is considered free if its memory usage is less than 100 MiB + # if [ "$MEM_USAGE" -ge 100 ]; then + # ALL_GPUS_FREE=0 + # echo "GPU $GPU_ID is in use. Memory used: ${MEM_USAGE}MiB." + # break # Exit the loop early as we found a GPU that is not free + # fi + # done + + # if [ $ALL_GPUS_FREE -eq 0 ]; then + # echo "Not all GPUs in chunk are free. Checking again in 100 seconds..." + # sleep 100 + # fi + # done + + echo "CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR" + CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR python3 llava/eval/model_video_description_from_t2v.py \ + --model-path $CKPT \ + --gt_file /mnt/bn/vl-research-1t/tuyen/webvid_hdvg_movie_pond5_for_captioning_evaluation/webvid_hdvg_movie_pond5_for_captioning_evaluation.processed.csv \ + --output_dir ./work_dirs/eval_video_description_from_t2v/$SAVE_DIR \ + --output_name pred \ + --num-chunks $CHUNKS \ + --chunk-idx $(($IDX - 1)) \ + --overwrite ${OVERWRITE} \ + --mm_spatial_pool_stride ${POOL_STRIDE:-4} \ + --for_get_frames_num $FRAMES \ + --load_8bit $LOAD_8BIT \ + --do_center_crop $DO_CENTER_CROP \ + --conv-mode $CONV_MODE & +done + +wait + +cat ${ROOT_DIR}/work_dirs/eval_video_description_from_t2v/$SAVE_DIR/${CHUNKS}* > ${ROOT_DIR}/work_dirs/eval_video_description_from_t2v/$SAVE_DIR/pred.json + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_detail_description_eval_only.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_detail_description_eval_only.sh new file mode 100644 index 0000000000000000000000000000000000000000..b75021ffb477025506660aedd7ea092bdbb048ce --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_detail_description_eval_only.sh @@ -0,0 +1,24 @@ +#!/bin/bash +ROOT_DIR="root to LLaVA-NeXT-Video" + +if [ ! -e $ROOT_DIR ]; then + echo "The root dir does not exist. Exiting the script." + exit 1 +fi + +cd $ROOT_DIR + +export PYTHONWARNINGS=ignore +export TOKENIZERS_PARALLELISM=false + +OPENAIKEY="INPUT YOUR OPENAI API" + +SAVE_DIR=$1 + +python3 llava/eval/evaluate_benchmark_video_detail_description.py \ + --pred_path ./work_dirs/eval_video_detail_description/$SAVE_DIR/pred.json \ + --output_dir ./work_dirs/eval_video_detail_description/$SAVE_DIR/detail_results \ + --output_json ./work_dirs/eval_video_detail_description/$SAVE_DIR/detail_results.json \ + --num_chunks 1 \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_detail_description_eval_shard.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_detail_description_eval_shard.sh new file mode 100644 index 0000000000000000000000000000000000000000..3b9de5caebbf6e4633432330a349006fa190c646 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/eval/video_detail_description_eval_shard.sh @@ -0,0 +1,95 @@ +#!/bin/bash +ROOT_DIR="/mnt/bn/vl-research/workspace/yhzhang/llava-next-video" + +if [ ! -e $ROOT_DIR ]; then + echo "The root dir does not exist. Exiting the script." + exit 1 +fi + +cd $ROOT_DIR + +export PYTHONWARNINGS=ignore +export TOKENIZERS_PARALLELISM=false + +OPENAIKEY="INPUT YOUR OPENAI API" + +CKPT=$1 +CONV_MODE=$2 +FRAMES=$3 +POOL_STRIDE=$4 +OVERWRITE=$5 +CHUNKS=${6:-1} + +echo "Using $CHUNKS GPUs" + +if [ "$OVERWRITE" = False ]; then + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE}_overwrite_${OVERWRITE} + +else + SAVE_DIR=$(basename $CKPT)_${CONV_MODE}_frames_${FRAMES}_stride_${POOL_STRIDE} +fi + +# Assuming GPULIST is a bash array containing your GPUs +GPULIST=(0 1 2 3 4 5 6 7) + +# Get the number of GPUs +NUM_GPUS=${#GPULIST[@]} + +# Calculate GPUs per chunk +GPUS_PER_CHUNK=$((NUM_GPUS / CHUNKS)) + + +for IDX in $(seq 1 $CHUNKS); do + START=$(((IDX-1) * GPUS_PER_CHUNK)) + LENGTH=$GPUS_PER_CHUNK # Length for slicing, not the end index + + CHUNK_GPUS=(${GPULIST[@]:$START:$LENGTH}) + + # Convert the chunk GPUs array to a comma-separated string + CHUNK_GPUS_STR=$(IFS=,; echo "${CHUNK_GPUS[*]}") + + # ALL_GPUS_FREE=0 + # while [ $ALL_GPUS_FREE -eq 0 ]; do + # ALL_GPUS_FREE=1 # Assume all GPUs are free initially + + # for GPU_ID in $CHUNK_GPUS; do + # MEM_USAGE=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits -i $GPU_ID | tr -d '[:space:]') + + # # Assuming a GPU is considered free if its memory usage is less than 100 MiB + # if [ "$MEM_USAGE" -ge 100 ]; then + # ALL_GPUS_FREE=0 + # echo "GPU $GPU_ID is in use. Memory used: ${MEM_USAGE}MiB." + # break # Exit the loop early as we found a GPU that is not free + # fi + # done + + # if [ $ALL_GPUS_FREE -eq 0 ]; then + # echo "Not all GPUs in chunk are free. Checking again in 100 seconds..." + # sleep 100 + # fi + # done + + echo "CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR" + CUDA_VISIBLE_DEVICES=$CHUNK_GPUS_STR python3 llava/eval/model_video_detail_description.py \ + --model-path $CKPT \ + --video_dir ./data/llava_video/video-chatgpt/evaluation/Test_Videos/ \ + --output_dir ./work_dirs/eval_video_detail_description/$SAVE_DIR \ + --output_name pred \ + --num-chunks $CHUNKS \ + --chunk-idx $(($IDX - 1)) \ + --overwrite ${OVERWRITE} \ + --mm_spatial_pool_stride ${POOL_STRIDE:-4} \ + --for_get_frames_num $FRAMES \ + --conv-mode $CONV_MODE & +done + +wait + +python3 llava/eval/evaluate_benchmark_video_detail_description.py \ + --pred_path ./work_dirs/eval_video_detail_description/$SAVE_DIR \ + --output_dir ./work_dirs/eval_video_detail_description/$SAVE_DIR/detail_results \ + --output_json ./work_dirs/eval_video_detail_description/$SAVE_DIR/detail_results.json \ + --num_chunks $CHUNKS \ + --num_tasks 16 \ + --api_key $OPENAIKEY \ + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/SO400M_Qwen2_72B_ov_to_video_am9.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/SO400M_Qwen2_72B_ov_to_video_am9.sh new file mode 100644 index 0000000000000000000000000000000000000000..5e053ffb5e6c4210a6a16508aff62866f22047e2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/SO400M_Qwen2_72B_ov_to_video_am9.sh @@ -0,0 +1,84 @@ +#!/bin/bash + +# Set up the data folder +IMAGE_FOLDER="XXX" +VIDEO_FOLDER="XXX" +DATA_YAML="XXX" # e.g exp.yaml + +############### Prepare Envs ################# +python3 -m pip install flash-attn --no-build-isolation +alias python=python3 +############### Show Envs #################### + +nvidia-smi + +################ Arnold Jobs ################ + +LLM_VERSION="Qwen/Qwen2-72B-Instruct" +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" + + +BASE_RUN_NAME="llavanext-google_siglip-so400m-patch14-384-Qwen_Qwen2-72B-Instruct-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +# Stage 2 +PROMPT_VERSION="qwen_1_5" +MID_RUN_NAME="llavanext-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-ov_to_video_am9" +PREV_STAGE_CHECKPOINT="lmms-lab/llava-onevision-qwen2-72b-ov-si" +echo "PREV_STAGE_CHECKPOINT: ${PREV_STAGE_CHECKPOINT}" +echo "MID_RUN_NAME: ${MID_RUN_NAME}" + + +# ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${ARNOLD_WORKER_GPU}" --nnodes="${ARNOLD_WORKER_NUM}" --node_rank="${ARNOLD_ID}" --master_addr="${METIS_WORKER_0_HOST}" --master_port="${port_in_cmd}" \ +deepspeed --master_port 30000 \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path $PREV_STAGE_CHECKPOINT \ + --version $PROMPT_VERSION \ + --data_path $DATA_YAML \ + --image_folder $IMAGE_FOLDER \ + --video_folder $VIDEO_FOLDER \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --mm_vision_tower_lr=2e-6 \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres_max_9 \ + --image_grid_pinpoints "(1x1),...,(6x6)" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $MID_RUN_NAME \ + --output_dir ./work_dirs/$MID_RUN_NAME \ + --num_train_epochs 1 \ + --per_device_train_batch_size 1 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 2 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 500 \ + --save_total_limit 1 \ + --learning_rate 1e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 2 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --frames_upbound 32 \ + --mm_newline_position grid \ + --add_time_instruction True \ + --force_sample True \ + --mm_spatial_pool_stride 2 +exit 0; \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/SO400M_Qwen2_7B_ov_to_video_am9.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/SO400M_Qwen2_7B_ov_to_video_am9.sh new file mode 100644 index 0000000000000000000000000000000000000000..14b915a0ce78a077954873b44524089325fb5706 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/SO400M_Qwen2_7B_ov_to_video_am9.sh @@ -0,0 +1,84 @@ +#!/bin/bash + +# Set up the data folder +IMAGE_FOLDER="XXX" +VIDEO_FOLDER="XXX" +DATA_YAML="XXX" # e.g exp.yaml + +############### Prepare Envs ################# +python3 -m pip install flash-attn --no-build-isolation +alias python=python3 +############### Show Envs #################### + +nvidia-smi + +################ Arnold Jobs ################ + +LLM_VERSION="Qwen/Qwen2-7B-Instruct" +LLM_VERSION_CLEAN="${LLM_VERSION//\//_}" +VISION_MODEL_VERSION="google/siglip-so400m-patch14-384" +VISION_MODEL_VERSION_CLEAN="${VISION_MODEL_VERSION//\//_}" +# + +BASE_RUN_NAME="llavanext-google_siglip-so400m-patch14-384-Qwen_Qwen2-7B-Instruct-mlp2x_gelu-pretrain_blip558k_plain" +echo "BASE_RUN_NAME: ${BASE_RUN_NAME}" + +# Stage 2 +PROMPT_VERSION="qwen_1_5" +MID_RUN_NAME="llavanext-${VISION_MODEL_VERSION_CLEAN}-${LLM_VERSION_CLEAN}-ov_to_video_am9" +PREV_STAGE_CHECKPOINT="lmms-lab/llava-onevision-qwen2-7b-ov-si" +echo "PREV_STAGE_CHECKPOINT: ${PREV_STAGE_CHECKPOINT}" +echo "MID_RUN_NAME: ${MID_RUN_NAME}" + + +# ACCELERATE_CPU_AFFINITY=1 torchrun --nproc_per_node="${ARNOLD_WORKER_GPU}" --nnodes="${ARNOLD_WORKER_NUM}" --node_rank="${ARNOLD_ID}" --master_addr="${METIS_WORKER_0_HOST}" --master_port="${port_in_cmd}" \ +deepspeed --master_port 30000 \ + llava/train/train_mem.py \ + --deepspeed scripts/zero3.json \ + --model_name_or_path $PREV_STAGE_CHECKPOINT \ + --version $PROMPT_VERSION \ + --data_path $DATA_YAML \ + --image_folder $IMAGE_FOLDER \ + --video_folder $VIDEO_FOLDER \ + --mm_tunable_parts="mm_vision_tower,mm_mlp_adapter,mm_language_model" \ + --mm_vision_tower_lr=2e-6 \ + --vision_tower ${VISION_MODEL_VERSION} \ + --mm_projector_type mlp2x_gelu \ + --mm_vision_select_layer -2 \ + --mm_use_im_start_end False \ + --mm_use_im_patch_token False \ + --group_by_modality_length True \ + --image_aspect_ratio anyres_max_9 \ + --image_grid_pinpoints "(1x1),...,(6x6)" \ + --mm_patch_merge_type spatial_unpad \ + --bf16 True \ + --run_name $MID_RUN_NAME \ + --output_dir ./work_dirs/$MID_RUN_NAME \ + --num_train_epochs 1 \ + --per_device_train_batch_size 1 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 2 \ + --evaluation_strategy "no" \ + --save_strategy "steps" \ + --save_steps 500 \ + --save_total_limit 1 \ + --learning_rate 1e-5 \ + --weight_decay 0. \ + --warmup_ratio 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --tf32 True \ + --model_max_length 32768 \ + --gradient_checkpointing True \ + --dataloader_num_workers 2 \ + --lazy_preprocess True \ + --report_to wandb \ + --torch_compile True \ + --torch_compile_backend "inductor" \ + --dataloader_drop_last True \ + --frames_upbound 64 \ + --mm_newline_position grid \ + --add_time_instruction True \ + --force_sample True \ + --mm_spatial_pool_stride 2 +exit 0; \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/exp.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/exp.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f093733d9c86e3e83e9d025f5eaa7b07219f7523 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/video/train/exp.yaml @@ -0,0 +1,263 @@ +datasets: + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_next_fit_mix_filtered_text_wild_738590.json + sampling_strategy: "first:50%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_wild_4v_39k.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_wild_4v_12k.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_metagen_87358.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mavis_math_rule_geo_100000.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/cambrian_filtered_gpt4vo_sp_token_fltd_max10k_checked.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/VisualWebInstruct_filtered_263589.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/visual_chat_en_26048_gpt4o_coco_checked.json + sampling_strategy: "all" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/gpt4o_combinations_51316.json + # sampling_strategy: "all" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/chrome_writting_train_8835.json + # sampling_strategy: "first:20%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/k12_printing_train_256646.json + # sampling_strategy: "first:1%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/iiit5k_annotations_2000.json + # sampling_strategy: "first:20%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/hme100k_train_clean_74502.json + # sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sroie_data_33626.json + # sampling_strategy: "first:1%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/orand_car_a_train_2009.json + # sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/orand_car_b_train_3000.json + # sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llavar_gpt4_20k.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_azuregpt_detailed_understanding_4874.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_vqa_4404.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/infographic_azuregpt4v_1992.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_chart_1787.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/lrv_normal_gpt4v_filtered_10500.json + sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/scienceqa_nona_context_19218.json + # sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_vflan4v_20000.json + sampling_strategy: "first:30%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/allava_instruct_laion4v_50000.json + sampling_strategy: "first:30%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textocr_gpt4v_train_converted_25114.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/ai2d_train_internvl_single_12413.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/textcaps_train_21952.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_qa_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_cap_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_ie_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/ureader_new/ureader_kg_sft.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/vision_flan_filtered_186070.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/mathqa_29837.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo3k_2101.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_qa_converted_67833.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/geo170k_align_converted_60252.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4o_dataset.jsonl + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-coco-50k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-knowledge-2k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-llava-30k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4v-sam-20k.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_CLEVR-Math_5290.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_FigureQA_17597.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Geometry3K_9734.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GeoQA+_17172.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_GEOS_508.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_IconQA_22599.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_MapQA_5235.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_PlotQA_5485.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_PMC-VQA_35958.json + sampling_strategy: "first:1%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_Super-CLEVR_8652.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TabMWP_22462.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_TQA_10181.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_UniGeo_11959.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VizWiz_6614.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VQA-AS_5907.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/MathV360K_VQA-RAD_2130.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_qwen2_72b_st_300000_sp_token_fltd_299992.json + sampling_strategy: "end:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_st_300000.json + sampling_strategy: "end:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/magpie_pro_l3_80b_mt_300000_sp_token_fltd_299998.json + sampling_strategy: "end:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/image_textualization_dataset_filtered.json + sampling_strategy: "first:20%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/ai2d_llava_format_2434.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/chart2text_26961.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/chartqa_18265_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/diagram_image_to_text_300.json + sampling_strategy: "all" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/hateful_memes_8500_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/hitab_2500_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/iam_5663.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/infographic_vqa_2118_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/intergps_1280_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/mapqa_37417_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/rendered_text_10000.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_sqa_8514.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wikisql_74989.json + sampling_strategy: "first:10%" + # - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/robut_wtq_38246_llava_format_filtered_4000tokens_38236.json + # sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/screen2words_15730.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tabmwp_22722.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tallyqa_98680_llava_format.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/st_vqa_17247_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/tqa_llava_format_27307.json + sampling_strategy: "first:5%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/visual7w_llava_format_14366.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/visualmrc_3027.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vqarad_313_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vsr_2157_llava_format.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/vistext_9969.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/cauldron/websight_10000.json + sampling_strategy: "first:10%" + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_ofa_DEMON-FULL_filtered_311085.json + sampling_strategy: all + - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/llava_ofa_mantis-instruct_reformatted.json + sampling_strategy: all + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/academic_source_30s_v1_all.json + # sampling_strategy: all + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/0718_0_30_s_academic_mc_v0_1_all.json + # sampling_strategy: all + # - json_path: /mnt/bn/vl-research/data/llava_instruct/real_vision_flan/sharegpt4video_255000.json + # sampling_strategy: all + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_academic_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_youtube_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_academic_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_youtube_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_academic_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_youtube_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_academic_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_academic_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_youtube_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_youtube_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_activitynetqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_nextqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_nextqa_mc_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/0_30_s_perceptiontest_mc_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_academic_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_academic_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_youtube_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_youtube_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_activitynetqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_nextqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_nextqa_mc_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/30_60_s_perceptiontest_mc_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_academic_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_academic_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_youtube_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_youtube_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_activitynetqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_nextqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/1_2_m_nextqa_mc_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/sharegptvideo_qa_255k.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_academic_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_youtube_v0_1_cap.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_academic_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_academic_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_youtube_oe_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_youtube_mc_v0_1_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_nextqa_oe_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_nextqa_mc_qa.json + sampling_strategy: "all" + - json_path: /mnt/bn/tiktok-mm-3/aiic/users/wujinming/_training_data/jsons/tos/2_3_m_activitynetqa_oe_qa.json + sampling_strategy: "all" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2.json new file mode 100644 index 0000000000000000000000000000000000000000..b5ba7ebea0f236230a5a41d72ec23ae1f64130d6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2.json @@ -0,0 +1,41 @@ +{ + "fp16": { + "enabled": "auto", + "loss_scale": 0, + "loss_scale_window": 1000, + "initial_scale_power": 16, + "hysteresis": 2, + "min_loss_scale": 1 + }, + "bf16": { + "enabled": "auto" + }, + "optimizer": { + "type": "AdamW", + "params": { + "lr": "auto", + "betas": "auto", + "eps": "auto", + "weight_decay": "auto" + } + }, + "zero_optimization": { + "stage": 2, + "offload_optimizer": { + "device": "none", + "pin_memory": true + }, + "allgather_partitions": true, + "allgather_bucket_size": 2e8, + "overlap_comm": false, + "reduce_scatter": true, + "reduce_bucket_size": 2e8, + "contiguous_gradients": true + }, + "gradient_accumulation_steps": "auto", + "gradient_clipping": "auto", + "steps_per_print": 100, + "train_batch_size": "auto", + "train_micro_batch_size_per_gpu": "auto", + "wall_clock_breakdown": false +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2_fused_adamw.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2_fused_adamw.json new file mode 100644 index 0000000000000000000000000000000000000000..0c37172f681bfe0c77b86bafa144507043fa86ba --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2_fused_adamw.json @@ -0,0 +1,41 @@ +{ + "fp16": { + "enabled": "auto", + "loss_scale": 0, + "loss_scale_window": 1000, + "initial_scale_power": 16, + "hysteresis": 2, + "min_loss_scale": 1 + }, + "bf16": { + "enabled": "auto" + }, + "optimizer": { + "type": "AdamW", + "params": { + "lr": "auto", + "betas": "auto", + "eps": "auto", + "weight_decay": "auto" + } + }, + "zero_optimization": { + "stage": 2, + "offload_optimizer": { + "device": "none", + "pin_memory": true + }, + "allgather_partitions": true, + "allgather_bucket_size": 2e8, + "overlap_comm": true, + "reduce_scatter": true, + "reduce_bucket_size": 2e8, + "contiguous_gradients": true + }, + "gradient_accumulation_steps": "auto", + "gradient_clipping": "auto", + "steps_per_print": 100, + "train_batch_size": "auto", + "train_micro_batch_size_per_gpu": "auto", + "wall_clock_breakdown": false +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2_offload.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2_offload.json new file mode 100644 index 0000000000000000000000000000000000000000..2d24e895bc0cffb2b2504c5ea85a49c7455d1070 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero2_offload.json @@ -0,0 +1,31 @@ +{ + "fp16": { + "enabled": "auto", + "loss_scale": 0, + "loss_scale_window": 1000, + "initial_scale_power": 16, + "hysteresis": 2, + "min_loss_scale": 1 + }, + "bf16": { + "enabled": "auto" + }, + "train_micro_batch_size_per_gpu": "auto", + "train_batch_size": "auto", + "gradient_accumulation_steps": "auto", + "zero_optimization": { + "stage": 2, + "offload_optimizer": { + "device": "cpu", + "pin_memory": true + }, + "offload_param": { + "device": "cpu", + "pin_memory": true + }, + "overlap_comm": true, + "contiguous_gradients": true, + "sub_group_size": 1e9, + "reduce_bucket_size": "auto" + } +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3.json new file mode 100644 index 0000000000000000000000000000000000000000..02d343165ec0eec3af55d3285f45911769af6109 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3.json @@ -0,0 +1,41 @@ +{ + "fp16": { + "enabled": "auto", + "loss_scale": 0, + "loss_scale_window": 1000, + "initial_scale_power": 16, + "hysteresis": 2, + "min_loss_scale": 1 + }, + "bf16": { + "enabled": "auto" + }, + + "zero_optimization": { + "stage": 3, + "offload_optimizer": { + "device": "none", + "pin_memory": true + }, + "offload_param": { + "device": "none", + "pin_memory": true + }, + "overlap_comm": true, + "contiguous_gradients": true, + "sub_group_size": 1e9, + "reduce_bucket_size": "auto", + "stage3_prefetch_bucket_size": "auto", + "stage3_param_persistence_threshold": "auto", + "stage3_max_live_parameters": 1e9, + "stage3_max_reuse_distance": 1e9, + "stage3_gather_16bit_weights_on_model_save": true + }, + + "gradient_accumulation_steps": "auto", + "gradient_clipping": "auto", + "steps_per_print": 100, + "train_batch_size": "auto", + "train_micro_batch_size_per_gpu": "auto", + "wall_clock_breakdown": false +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3_offload.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3_offload.json new file mode 100644 index 0000000000000000000000000000000000000000..9da12de56b44374047644fe77607a85ced885e7c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3_offload.json @@ -0,0 +1,48 @@ +{ + "fp16": { + "enabled": "auto", + "loss_scale": 0, + "loss_scale_window": 1000, + "initial_scale_power": 16, + "hysteresis": 2, + "min_loss_scale": 1 + }, + "bf16": { + "enabled": "auto" + }, + "optimizer": { + "type": "AdamW", + "params": { + "lr": "auto", + "betas": "auto", + "eps": "auto", + "weight_decay": "auto" + } + }, + "zero_optimization": { + "stage": 3, + "offload_optimizer": { + "device": "cpu", + "pin_memory": true + }, + "offload_param": { + "device": "cpu", + "pin_memory": true + }, + "overlap_comm": true, + "contiguous_gradients": true, + "sub_group_size": 1e9, + "reduce_bucket_size": "auto", + "stage3_prefetch_bucket_size": "auto", + "stage3_param_persistence_threshold": "auto", + "stage3_max_live_parameters": 1e9, + "stage3_max_reuse_distance": 1e9, + "gather_16bit_weights_on_model_save": true + }, + "gradient_accumulation_steps": "auto", + "gradient_clipping": "auto", + "train_batch_size": "auto", + "train_micro_batch_size_per_gpu": "auto", + "steps_per_print": 1e5, + "wall_clock_breakdown": false +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3pp.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3pp.json new file mode 100644 index 0000000000000000000000000000000000000000..f7ca45f95a00ad0923952c914cccf09f9dee485a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/scripts/zero3pp.json @@ -0,0 +1,53 @@ +{ + "fp16": { + "enabled": "auto", + "loss_scale": 0, + "loss_scale_window": 1000, + "initial_scale_power": 16, + "hysteresis": 2, + "min_loss_scale": 1 + }, + "bf16": { + "enabled": "auto" + }, + "optimizer": { + "type": "AdamW", + "params": { + "lr": "auto", + "betas": "auto", + "eps": "auto", + "weight_decay": "auto" + } + }, + + "zero_optimization": { + "stage": 3, + "offload_optimizer": { + "device": "none", + "pin_memory": true + }, + "offload_param": { + "device": "none", + "pin_memory": true + }, + "overlap_comm": true, + "contiguous_gradients": true, + "zero_quantized_weights": true, + "zero_hpz_partition_size": 16, + "zero_quantized_gradients": true, + "sub_group_size": 1e9, + "reduce_bucket_size": "auto", + "stage3_prefetch_bucket_size": "auto", + "stage3_param_persistence_threshold": "auto", + "stage3_max_live_parameters": 1e9, + "stage3_max_reuse_distance": 1e9, + "stage3_gather_16bit_weights_on_model_save": true + }, + + "gradient_accumulation_steps": "auto", + "gradient_clipping": "auto", + "steps_per_print": 100, + "train_batch_size": "auto", + "train_micro_batch_size_per_gpu": "auto", + "wall_clock_breakdown": false +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9a1a6b856eb7c7bedcdfb0fbc5d41a2d44c9fe6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/__init__.py @@ -0,0 +1,44 @@ +# flake8: noqa + +__version__ = "0.7.11.dev0" + +from .core import set_seed +from .environment import TextEnvironment, TextHistory +from .extras import BestOfNSampler +from .import_utils import ( + is_bitsandbytes_available, + is_diffusers_available, + is_npu_available, + is_peft_available, + is_wandb_available, + is_xpu_available, +) +from .models import ( + AutoModelForCausalLMWithValueHead, + AutoModelForSeq2SeqLMWithValueHead, + PreTrainedModelWrapper, + create_reference_model, + setup_chat_format, +) +from .trainer import ( + DataCollatorForCompletionOnlyLM, + DPOTrainer, + IterativeSFTTrainer, + ModelConfig, + PPOConfig, + PPOTrainer, + RewardConfig, + RewardTrainer, + SFTTrainer, +) +from .trainer.utils import get_kbit_device_map, get_peft_config, get_quantization_config + + +if is_diffusers_available(): + from .models import ( + DDPOPipelineOutput, + DDPOSchedulerOutput, + DDPOStableDiffusionPipeline, + DefaultDDPOStableDiffusionPipeline, + ) + from .trainer import DDPOConfig, DDPOTrainer diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/core.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/core.py new file mode 100644 index 0000000000000000000000000000000000000000..4cf481e0fe04998784f816c8f6250f9bb072efee --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/core.py @@ -0,0 +1,329 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import gc +import random +import warnings +from contextlib import contextmanager +from typing import Dict, List, Optional, Tuple, Union + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.nn.utils.rnn import pad_sequence + +# from transformers import top_k_top_p_filtering + +from .import_utils import is_npu_available, is_xpu_available + + +try: + from collections.abc import Mapping +except ImportError: + from collections import Mapping + + +WANDB_PADDING = -1 + + +def top_k_top_p_filtering( + logits: torch.FloatTensor, + top_k: int = 0, + top_p: float = 1.0, + filter_value: float = -float("Inf"), + min_tokens_to_keep: int = 1, +) -> torch.FloatTensor: + """ + Filter a distribution of logits using top-k and/or nucleus (top-p) filtering. + + Args: + logits: logits distribution shape (batch size, vocabulary size) + top_k (`int`, *optional*, defaults to 0): + If > 0, only keep the top k tokens with highest probability (top-k filtering) + top_p (`float`, *optional*, defaults to 1.0): + If < 1.0, only keep the top tokens with cumulative probability >= top_p (nucleus filtering). Nucleus + filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751) + min_tokens_to_keep (`int`, *optional*, defaults to 1): + Minimumber of tokens we keep per batch example in the output. + + From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317 + """ + + if top_k > 0: + logits = TopKLogitsWarper(top_k=top_k, filter_value=filter_value, min_tokens_to_keep=min_tokens_to_keep)(None, logits) + + if 0 <= top_p <= 1.0: + logits = TopPLogitsWarper(top_p=top_p, filter_value=filter_value, min_tokens_to_keep=min_tokens_to_keep)(None, logits) + + return logits + + +def flatten_dict(nested: Dict, sep: str = "/") -> Dict: + """Flatten dictionary and concatenate nested keys with separator.""" + + def recurse(nest: Dict, prefix: str, into: Dict) -> None: + for k, v in nest.items(): + if sep in k: + raise ValueError(f"separator '{sep}' not allowed to be in key '{k}'") + if isinstance(v, Mapping): + recurse(v, prefix + k + sep, into) + else: + into[prefix + k] = v + + flat = {} + recurse(nested, "", flat) + return flat + + +def convert_to_scalar(stats: Dict) -> Dict: + """ + Converts the stats from a flattened dict to single scalar dicts + """ + tensorboard_stats = {} + for k, v in stats.items(): + # for tensorboard compatibility - arrays and tensors are ignored with tensorboard + # therefore we convert single element tensors to scalars + if (isinstance(v, torch.Tensor) or isinstance(v, np.ndarray)) and (len(v.shape) == 0 or (len(v.shape) == 1 and v.shape[0] == 1)): + v = v.item() + tensorboard_stats[k] = v + return tensorboard_stats + + +def stack_dicts(stats_dicts: List[Dict]) -> Dict: + """Stack the values of a dict.""" + results = dict() + for k in stats_dicts[0]: + stats_list = [torch.flatten(d[k]) for d in stats_dicts] + results[k] = pad_sequence(stats_list, batch_first=True, padding_value=WANDB_PADDING) + return results + + +def add_suffix(input_dict: Dict, suffix: str) -> Dict: + """Add suffix to dict keys.""" + return dict((k + suffix, v) for k, v in input_dict.items()) + + +def pad_to_size(tensor: torch.Tensor, size: int, dim: int = 1, padding: int = 50256) -> torch.Tensor: + """Pad tensor to size.""" + t_size = tensor.size()[dim] + if t_size == size: + return tensor + else: + return torch.nn.functional.pad(tensor, (0, size - t_size), "constant", padding) + + +def logprobs_from_logits(logits: torch.Tensor, labels: torch.Tensor, gather: bool = True) -> torch.Tensor: + """ + See: https://github.com/pytorch/pytorch/issues/563#issuecomment-330103591 + """ + logp = F.log_softmax(logits, dim=2) + + if not gather: + return logp + logpy = torch.gather(logp, 2, labels.unsqueeze(2)).squeeze(-1) + return logpy + + +def whiten(values: torch.Tensor, shift_mean: bool = True) -> torch.Tensor: + """Whiten values.""" + mean, var = torch.mean(values), torch.var(values) + whitened = (values - mean) * torch.rsqrt(var + 1e-8) + if not shift_mean: + whitened += mean + return whitened + + +def masked_mean(values: torch.Tensor, mask: torch.Tensor, axis: bool = None) -> torch.Tensor: + """Compute mean of tensor with a masked values.""" + if axis is not None: + return (values * mask).sum(axis=axis) / mask.sum(axis=axis) + else: + return (values * mask).sum() / mask.sum() + + +def masked_var(values: torch.Tensor, mask: torch.Tensor, unbiased: bool = True) -> torch.Tensor: + """Compute variance of tensor with masked values.""" + mean = masked_mean(values, mask) + centered_values = values - mean + variance = masked_mean(centered_values**2, mask) + if unbiased: + mask_sum = mask.sum() + if mask_sum == 0: + raise ValueError("The sum of the mask is zero, which can happen when `mini_batch_size=1`;" "try increase the `mini_batch_size` or `gradient_accumulation_steps`") + # note that if mask_sum == 1, then there is a division by zero issue + # to avoid it you just need to use a larger minibatch_size + bessel_correction = mask_sum / (mask_sum - 1) + variance = variance * bessel_correction + return variance + + +def masked_whiten(values: torch.Tensor, mask: torch.Tensor, shift_mean: bool = True) -> torch.Tensor: + """Whiten values with masked values.""" + mean, var = masked_mean(values, mask), masked_var(values, mask) + whitened = (values - mean) * torch.rsqrt(var + 1e-8) + if not shift_mean: + whitened += mean + return whitened + + +def clip_by_value(x: torch.Tensor, tensor_min: float, tensor_max: float) -> torch.Tensor: + """ + Tensor extension to torch.clamp + https://github.com/pytorch/pytorch/issues/2793#issuecomment-428784713 + """ + clipped = torch.max(torch.min(x, tensor_max), tensor_min) + return clipped + + +def entropy_from_logits(logits: torch.Tensor) -> torch.Tensor: + """Calculate entropy from logits.""" + pd = torch.nn.functional.softmax(logits, dim=-1) + entropy = torch.logsumexp(logits, axis=-1) - torch.sum(pd * logits, axis=-1) + return entropy + + +def average_torch_dicts(list_of_dicts: List[Dict]) -> Dict: + """Average values of a list of dicts with torch tensors.""" + average_dict = dict() + for key in list_of_dicts[0].keys(): + average_dict[key] = torch.mean(torch.stack([d[key] for d in list_of_dicts]), axis=0) + return average_dict + + +def stats_to_np(stats_dict: Dict) -> Dict: + """Cast all torch.tensors in dict to numpy arrays.""" + new_dict = dict() + for k, v in stats_dict.items(): + if isinstance(v, torch.Tensor): + new_dict[k] = v.detach().cpu() + if new_dict[k].dtype == torch.bfloat16: + new_dict[k] = new_dict[k].float() + new_dict[k] = new_dict[k].numpy() + else: + new_dict[k] = v + if np.isscalar(new_dict[k]): + new_dict[k] = float(new_dict[k]) + return new_dict + + +def respond_to_batch(model: nn.Module, queries: List[torch.LongTensor], txt_len: int = 20, top_k: int = 0, top_p: float = 1.0) -> torch.LongTensor: + """Sample text from language model.""" + input_ids = queries + for i in range(txt_len): + # Get Logits + outputs = model(input_ids) + next_token_logits = outputs[0][:, -1, :] + next_token_logits = top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p) + # Sample + probs = F.softmax(next_token_logits, dim=-1) + next_token = torch.multinomial(probs, num_samples=1).squeeze(1) + input_ids = torch.cat([input_ids, next_token.unsqueeze(-1)], dim=-1) + return input_ids[:, -txt_len:] + + +def set_seed(seed: int) -> None: + """ + Helper function for reproducible behavior to set the seed in `random`, `numpy`, and `torch`. + + Args: + seed (`int`): The seed to set. + """ + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + if is_xpu_available(): + torch.xpu.manual_seed_all(seed) + elif is_npu_available(): + torch.npu.manual_seed_all(seed) + else: + torch.cuda.manual_seed_all(seed) + + +class LengthSampler: + """ + Samples a length + """ + + def __init__(self, min_value: int, max_value: int): + self.values = list(range(min_value, max_value)) + + def __call__(self) -> int: + return np.random.choice(self.values) + + +class PPODecorators(object): + optimize_device_cache = False + + @classmethod + @contextmanager + def empty_device_cache(cls): + yield + if cls.optimize_device_cache: + if is_xpu_available(): + gc.collect() + torch.xpu.empty_cache() + gc.collect() + elif is_npu_available(): + gc.collect() + torch.npu.empty_cache() + gc.collect() + elif torch.cuda.is_available(): + gc.collect() + torch.cuda.empty_cache() + gc.collect() + + +def randn_tensor( + shape: Union[Tuple, List], + generator: Optional[Union[List[torch.Generator], torch.Generator]] = None, + device: Optional[torch.device] = None, + dtype: Optional[torch.dtype] = None, + layout: Optional[torch.layout] = None, +) -> torch.Tensor: + """A helper function to create random tensors on the desired `device` with the desired `dtype`. When + passing a list of generators, you can seed each batch size individually. If CPU generators are passed, the tensor + is always created on the CPU. + """ + # device on which tensor is created defaults to device + rand_device = device + batch_size = shape[0] + + layout = layout or torch.strided + device = device or torch.device("cpu") + + if generator is not None: + gen_device_type = generator.device.type if not isinstance(generator, list) else generator[0].device.type + if gen_device_type != device.type and gen_device_type == "cpu": + rand_device = "cpu" + if device != "mps": + warnings.warn( + f"The passed generator was created on 'cpu' even though a tensor on {device} was expected." + f" Tensors will be created on 'cpu' and then moved to {device}. Note that one can probably" + f" slighly speed up this function by passing a generator that was created on the {device} device." + ) + elif gen_device_type != device.type and gen_device_type == "cuda": + raise ValueError(f"Cannot generate a {device} tensor from a generator of type {gen_device_type}.") + + # make sure generator list of length 1 is treated like a non-list + if isinstance(generator, list) and len(generator) == 1: + generator = generator[0] + + if isinstance(generator, list): + shape = (1,) + shape[1:] + latents = [torch.randn(shape, generator=generator[i], device=rand_device, dtype=dtype, layout=layout) for i in range(batch_size)] + latents = torch.cat(latents, dim=0).to(device) + else: + latents = torch.randn(shape, generator=generator, device=rand_device, dtype=dtype, layout=layout).to(device) + + return latents diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/environment/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/environment/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ae1cda4ecb2e604cc990ce16d982df29846f5204 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/environment/__init__.py @@ -0,0 +1,3 @@ +# flake8: noqa + +from .base_environment import TextEnvironment, TextHistory diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/environment/base_environment.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/environment/base_environment.py new file mode 100644 index 0000000000000000000000000000000000000000..4c06b1c8d632c9128aa02db670cc2065589fc643 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/environment/base_environment.py @@ -0,0 +1,463 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import re +import warnings + +import torch +from accelerate.utils import extract_model_from_parallel +from transformers import StoppingCriteria, StoppingCriteriaList + +from ..import_utils import is_rich_available + + +if is_rich_available(): + from rich import print + from rich.text import Text + + +class StringStoppingCriteria(StoppingCriteria): + """Custom `StoppingCriteria` which checks if all generations in the batch are completed.""" + + def __init__(self, stop_strings, tokenizer): + self.stop_strings = stop_strings + self.tokenizer = tokenizer + self.first_call = True + + def __call__(self, input_ids, scores, **kwargs): + """Returns true if all generated sequences contain any of the stop strings.""" + if self.first_call: + self.generated_tokens = [1 for _ in range(input_ids.shape[0])] + self.start_length = input_ids.shape[-1] - 1 + self.first_call = False + decoded_generations = self.tokenizer.batch_decode(input_ids[:, self.start_length :]) + done = [] + + for i, decoded_generation in enumerate(decoded_generations): + sequence_complete = any([stop_string in decoded_generation for stop_string in self.stop_strings]) + done.append(sequence_complete) + if not sequence_complete: + self.generated_tokens[i] += 1 + + if all(done): + self.first_call = True + + return all(done) + + +class TextHistory: + """The TextHistory class keeps track of the history of an interaction between the language model and the environment.""" + + def __init__(self, text, tokens, system=True): + """ + Initialize TextHistory. + + args: + text (`str`): The text of the first segment. + tokens (`torch.LongTensor`): The tokens of the first segment. + system (`bool`, *optional*): Whether the first segment is a system or user segment. + """ + self.system_spans = [] + self.text_spans = [] + self.token_spans = [] + self.token_masks = torch.tensor([], dtype=torch.long).to(tokens.device) + self.text = "" + self.tokens = torch.tensor([], dtype=torch.long).to(tokens.device) + self.completed = False + self.truncated = False + self.reward = 0.0 + + self.prompt_color = "black on grey85" + self.system_color = "black on cyan3" + self.model_color = "black on deep_sky_blue1" + self.reward_color = "black on plum1" + + self.append_segment(text, tokens, system=system) + + def append_segment(self, text, tokens, system=True): + """ + Append a new segment to the history. + + args: + text (`str`): The text of the new segment. + tokens (`torch.LongTensor`): The tokens of the new segment. + system (`bool`, *optional*): Whether the new segment is a system or user segment. + """ + + if len(text) == 0 or len(tokens) == 0: + raise ValueError("Can't append empty text or token list to history.") + + original_text_length = len(self.text) + + self.text += text + self.text_spans.append((original_text_length, len(self.text))) + self.system_spans.append(system) + + original_token_length = len(self.tokens) + + self.tokens = torch.cat((self.tokens, tokens)) + if system: + self.token_masks = torch.cat((self.token_masks, torch.zeros_like(tokens))) + else: + self.token_masks = torch.cat((self.token_masks, torch.ones_like(tokens))) + self.token_spans.append((original_token_length, len(self.tokens))) + + def complete(self, truncated=False): + """ + Mark the history as completed. + """ + self.completed = True + self.truncated = truncated + + @property + def last_text_segment(self): + """ + Get the last text segment. + """ + start, end = self.text_spans[-1] + return self.text[start:end] + + def split_query_response_tokens(self): + """ + Split the tokens into query and response tokens. + """ + split_index = self.token_spans[0][1] + query = self.tokens[:split_index] + response = self.tokens[split_index:] + mask = self.token_masks[split_index:] + + return query, response, mask + + def show_text(self, show_legend=False): + """ + Print the text history. + """ + if not is_rich_available(): + warnings.warn("install rich to display text") + return + + text = Text(self.text) + text.stylize(self.prompt_color, self.text_spans[0][0], self.text_spans[1][0]) + for i, (start, end) in enumerate(self.text_spans[1:]): + if self.system_spans[i + 1]: + text.stylize(self.system_color, start, end) + else: + text.stylize(self.model_color, start, end) + + text.append(f"\n\nReward: {self.reward}", style=self.reward_color) + print(text) + + if show_legend: + self.show_colour_legend() + + def show_tokens(self, tokenizer, show_legend=False): + """ + Print the history tokens. + """ + if not is_rich_available(): + warnings.warn("install rich to display tokens") + return + + text = Text() + prompt_end = self.token_spans[0][1] + for i, (token, mask) in enumerate(zip(self.tokens, self.token_masks)): + if i < prompt_end: + text.append(tokenizer.convert_ids_to_tokens(token.item()), style=self.prompt_color) + text.append(" ") + elif mask == 0: + text.append(tokenizer.convert_ids_to_tokens(token.item()), style=self.system_color) + text.append(" ") + else: + text.append(tokenizer.convert_ids_to_tokens(token.item()), style=self.model_color) + text.append(" ") + text.append(f"\n\nReward: {self.reward}", style=self.reward_color) + print(text) + if show_legend: + self.show_colour_legend() + + def show_colour_legend(self): + """ + Print the colour legend. + """ + if not is_rich_available(): + warnings.warn("install rich to display colour legend") + return + text = Text("\n\n(Colour Legend: ") + text.append("Prompt", style=self.prompt_color) + text.append("|") + text.append("System", style=self.system_color) + text.append("|") + text.append("Model", style=self.model_color) + text.append("|") + text.append("Reward", style=self.reward_color) + text.append(")") + print(text) + + +class TextEnvironment: + """ + The TextEnvironment enables interaction of a LLM with an environment using tools. + """ + + def __init__( + self, + model=None, + tokenizer=None, + tools=None, + reward_fn=None, + prompt=None, + max_turns=4, + max_tool_reponse=100, + max_length=None, + generation_kwargs=None, + ): + """ + Initialize TextEnvironment. + + Args: + model (`PreTrainedModelWrapper`): The model to use for generation. + tokenizer (`transformers.PreTrainedTokenizer`): The tokenizer to use for generation. + tools (list): A list of tools to use for interaction. + reward_fn (function): A function that takes a string and returns a reward. + prompt (str): The base prompt to use for generation. Is prepended to the tasks. + max_turns (Optional[int]): The maximum number of turns to allow. + max_tool_response (Optional[int]): The maximum number of characters to allow in a tool response. + max_length (Optional[int]): The maximum number of tokens to allow in an episode. + generation_kwargs (Optional[dict]): A dictionary of keyword arguments to pass to the model's generate method. + """ + self.model = model + self.tokenizer = tokenizer + self.prompt = prompt + if isinstance(tools, dict): + self.tools = tools + else: + self.tools = dict([(tool.__class__.__name__, tool) for tool in tools]) + self.reward_fn = reward_fn + self.max_length = max_length + self.request_token = "" + self.call_token = "" + self.response_token = "" + self.submit_token = "" + self.max_turns = max_turns + self.max_tool_response = max_tool_reponse + + if generation_kwargs is None: + self.generation_kwargs = dict() + else: + self.generation_kwargs = generation_kwargs + + self.is_encoder_decoder = hasattr(self.model, "is_encoder_decoder") + self.current_device = extract_model_from_parallel(self.model).pretrained_model.device + + def run(self, queries, **rewards_kwargs): + """ + Run the environment on a list of queries. + + Args: + queries (list[str]): A list of queries to run the model in the environment on. + """ + turns = 0 + + queries = [self.prompt + task for task in queries] + queries_tokens = [self.tokenizer(query, return_tensors="pt").input_ids[0].to(self.model.pretrained_model.device) for query in queries] + + histories = [TextHistory(q, qt, system=True) for q, qt in zip(queries, queries_tokens)] + + while any([not history.completed for history in histories]) and turns < self.max_turns: + histories = self.generate(histories) + histories = self.tasks_end_check(histories) + # TODO: make this parallel rather than for-loop + for i in range(len(histories)): + histories[i] = self.step(histories[i]) + histories = self.tasks_end_check(histories, model_turn=False) + turns += 1 + self.compute_reward(histories, **rewards_kwargs) + + # convert a list of (q, r, m) tuples to lists of all qs, rs, and ms respectively + queries, responses, masks = map(list, zip(*[history.split_query_response_tokens() for history in histories])) + + rewards = [history.reward for history in histories] + return queries, responses, masks, rewards, histories + + def step(self, history): + """ + Step the environment forward one turn. + + Args: + history (`TextHistory`): The history to step forward. + """ + truncated, ended = self.task_end_check(history) + if ended: + history.complete(truncated=truncated) + if history.completed: + return history + + tool, query = self.parse_tool_call(history.last_text_segment) + if tool is None or query is None: + response = f"Unknown tool call: {history.last_text_segment}" + else: + if tool not in self.tools: + response = f"Unknown tool {tool}." + try: + response = self.tools[tool](query) + except Exception as error: + response = f"Tool error: {str(error)}" + + if len(response) > self.max_tool_response: + response = response[: (self.max_tool_response - 3)] + "..." + + history.append_segment( + response + self.response_token, + self.tokenizer(response + self.response_token, return_tensors="pt").input_ids[0].to(self.model.pretrained_model.device), + system=True, + ) + + return history + + def parse_tool_call(self, text): + """ + Parse request string. Expected format: query + """ + result = re.search(f"(?<={self.request_token}).*?(?={self.call_token})", text, re.DOTALL) + + # if we can't find a / span we return none + if result is None: + return None, None + else: + extracted_text = result.group() + + result = re.search(r"<(.*?)>", extracted_text) + + # if we can't find a tool name we return none + if result is None: + return None, None + else: + tool = result.group(1) + + # split off the tool name + query = ">".join(extracted_text.split(">")[1:]) + + return tool, query + + def compute_reward(self, histories, **reward_kwargs): + """ + Compute the reward for a list of histories. + """ + rewards = self.reward_fn([history.last_text_segment for history in histories], **reward_kwargs) + for history, reward in zip(histories, rewards): + history.reward = reward + return histories + + def generate(self, histories): + """ + Generate responses for a list of histories. + """ + active_histories = [i for i, history in enumerate(histories) if not history.completed] + + query_tensors = [histories[i].tokens for i in active_histories] + response_tensors = self._generate_batched(query_tensors) + response_texts = self.tokenizer.batch_decode(response_tensors) + + for i, response_text, response_tensor in zip(active_histories, response_texts, response_tensors): + histories[i].append_segment(response_text, response_tensor, system=False) + + return histories + + def tasks_end_check(self, histories, model_turn=True): + """ + Check if the current generation sequences have finished. + """ + for history in histories: + if not history.completed: + truncated, ended = self.task_end_check(history, model_turn=model_turn) + if ended: + history.complete(truncated=truncated) + return histories + + def task_end_check(self, history, model_turn=True): + """ + Check if the current generation sequence has finished. + """ + truncated = False + ended = False + if history.completed: + return truncated, ended + if self.max_length is not None and len(self.tokenizer(history.text).input_ids[0]) > self.max_length: + truncated = True + ended = True + elif self.tokenizer.eos_token in history.text: + ended = True + elif model_turn and not ((self.request_token in history.last_text_segment and self.call_token in history.last_text_segment) or self.submit_token in history.last_text_segment): + ended = True + elif self.submit_token in history.last_text_segment: + ended = True + return truncated, ended + + def _generate_batched( + self, + query_tensors, + batch_size: int = 16, + pad_to_multiple_of: int = None, + ): + """ + Generate responses for a list of query tensors. + + args: + query_tensors (list[torch.Tensor]): A list of query tensors to generate responses for. + batch_size (int): The batch size to use for generation. + pad_to_multiple_of (int): The padding length to use for generation. + """ + outputs = [] + padding_side_default = self.tokenizer.padding_side + if not self.is_encoder_decoder: + self.tokenizer.padding_side = "left" + + # in case we have fewer examples than bs + batch_size = min(len(query_tensors), batch_size) + + for i in range(0, len(query_tensors), batch_size): + # prevent overflow if query tensors are not even multiple of bs + end_index = min(len(query_tensors), i + batch_size) + + batch = query_tensors[i:end_index] + batch_mask = [torch.ones_like(element) for element in batch] + inputs = {"input_ids": batch, "attention_mask": batch_mask} + + padded_inputs = self.tokenizer.pad( + inputs, + padding=True, + max_length=None, + pad_to_multiple_of=pad_to_multiple_of, + return_tensors="pt", + ).to(self.current_device) + + stopping_criteria = StringStoppingCriteria([self.call_token, self.submit_token], self.tokenizer) + + self.generation_kwargs["stopping_criteria"] = StoppingCriteriaList([stopping_criteria]) + + generations = extract_model_from_parallel(self.model).generate(**padded_inputs, **self.generation_kwargs) + + for generation, mask, generated_tokens in zip(generations, padded_inputs["attention_mask"], stopping_criteria.generated_tokens): + if not self.is_encoder_decoder: + output = generation[(1 - mask).sum() :] # remove padding + else: + output = generation + + if not self.is_encoder_decoder: + output = output[(mask).sum() :] # remove prompt + + # remove chunk generated after stopping criteria in batch mode + outputs.append(output[:generated_tokens]) + self.tokenizer.padding_side = padding_side_default + return outputs diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b3035db92af28f5d19d72813f08b06fdad50925 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/__init__.py @@ -0,0 +1,16 @@ +# flake8: noqa + +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from .best_of_n_sampler import BestOfNSampler diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/best_of_n_sampler.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/best_of_n_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..b64231f73dad58faf31b259e2205d278f6383c3a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/best_of_n_sampler.py @@ -0,0 +1,113 @@ +from typing import Any, Callable, List, Optional, Union + +import torch +from transformers import GenerationConfig, PreTrainedTokenizer, PreTrainedTokenizerFast + +from ..core import set_seed +from ..models import SUPPORTED_ARCHITECTURES, PreTrainedModelWrapper + + +class BestOfNSampler(object): + def __init__( + self, + model: PreTrainedModelWrapper, + tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast], + queries_to_scores: Callable[[List[str]], List[float]], + length_sampler: Any, + sample_size: int = 4, + seed: Optional[int] = None, + n_candidates: int = 1, + generation_config: Optional[GenerationConfig] = None, + ) -> None: + r""" + Initialize the sampler for best-of-n generation + + Args: + model (`PreTrainedModelWrapper`): + The pretrained model to use for generation + tokenizer (`PreTrainedTokenizer` or `PreTrainedTokenizerFast`): + Tokenizer associated with the pretrained model + queries_to_scores (`Callable[[List[str]], List[float]]`): + Callable that takes a list of generated texts and returns the associated reward scores + length_sampler (`Any`): + Sampler used to sample the length of the generated text + sample_size (`int`): + Number of samples to generate for each query + seed (`int`, *optional*): + Random seed used to control generation + n_candidates (`int`): + Number of candidates to return for each query + generation_config (`GenerationConfig`, *optional*): + Generation config passed to the underlying model's `generate` method. + See `GenerationConfig` (https://huggingface.co/docs/transformers/v4.29.1/en/main_classes/text_generation#transformers.GenerationConfig) for more details + """ + if seed is not None: + set_seed(seed) + + if not isinstance(tokenizer, (PreTrainedTokenizer, PreTrainedTokenizerFast)): + raise ValueError(f"tokenizer must be a PreTrainedTokenizer or PreTrainedTokenizerFast, got {type(tokenizer)}") + if not isinstance(model, (SUPPORTED_ARCHITECTURES)): + raise ValueError(f"model must be a PreTrainedModelWrapper, got {type(model)} - supported architectures are: {SUPPORTED_ARCHITECTURES}") + + self.model = model + self.tokenizer = tokenizer + + self.queries_to_scores = queries_to_scores + self.length_sampler = length_sampler + self.gen_config = generation_config + self.sample_size = sample_size + self.n_candidates = n_candidates + + def generate( + self, + tokenized_query: Union[List[int], torch.Tensor, List[torch.Tensor], List[List[int]]], + skip_special_tokens: bool = True, + device: Optional[Union[str, torch.device]] = None, + **generation_kwargs, + ) -> List[List[str]]: + r""" + Generate the best of n samples for input queries + + Args: + tokenized_query (`List[int]` or `torch.Tensor` or `List[torch.Tensor]` or `List[int]`): + represents either a single tokenized query (a single tensor or a list of integers) or a batch of tokenized queries (a list of tensors or a list of lists of integers) + skip_special_tokens (`bool`): + Whether to remove the special tokens from the output + device (`str` or `torch.device`, *optional*): + The device on which the model will be loaded + **generation_kwargs (`dict`, *optional*): + Additional keyword arguments passed along to the underlying model's `generate` method. + This is used to override generation config + + Returns: + List[List[str]]: A list of lists of generated texts + """ + queries = None + + if isinstance(tokenized_query, torch.Tensor) and tokenized_query.ndim == 1: + queries = tokenized_query.unsqueeze(0) + elif isinstance(tokenized_query, List): + element_type = type(tokenized_query[0]) + if element_type == int: + queries = torch.tensor(tokenized_query).unsqueeze(0) + elif element_type == torch.Tensor: + queries = [tensor.reshape((1, -1)) for tensor in tokenized_query] + else: + queries = [torch.tensor(query).reshape((1, -1)) for query in tokenized_query] + + result = [] + + for query in queries: + queries = query.repeat((self.sample_size, 1)) + output = self.model.generate( + queries.to(device), + max_new_tokens=self.length_sampler(), + generation_config=self.gen_config, + **generation_kwargs, + ).squeeze() + output = self.tokenizer.batch_decode(output, skip_special_tokens=skip_special_tokens) + scores = torch.tensor(self.queries_to_scores(output)) + output = [output[i] for i in scores.topk(self.n_candidates).indices] + result.append(output) + + return result diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/dataset_formatting.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/dataset_formatting.py new file mode 100644 index 0000000000000000000000000000000000000000..b9a691bf588ac7cfc029ac86eeaf70b4e84283f9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/extras/dataset_formatting.py @@ -0,0 +1,86 @@ +import logging +from typing import Callable, Literal, Optional, Union + +from datasets import Dataset, Value +from transformers import AutoTokenizer + +from ..trainer.utils import ConstantLengthDataset + + +FORMAT_MAPPING = { + "chatml": [{"content": Value(dtype="string", id=None), "role": Value(dtype="string", id=None)}], + "instruction": {"completion": Value(dtype="string", id=None), "prompt": Value(dtype="string", id=None)}, +} + + +def conversations_formatting_function(tokenizer: AutoTokenizer, messages_field: Literal["messages", "conversations"]): + r""" + return a callable function that takes in a "messages" dataset and returns a formatted dataset, based on the tokenizer + apply chat template to the dataset + """ + + def format_dataset(examples): + if isinstance(examples[messages_field][0], list): + output_texts = [] + for i in range(len(examples[messages_field])): + output_texts.append(tokenizer.apply_chat_template(examples[messages_field][i], tokenize=False)) + return output_texts + else: + return tokenizer.apply_chat_template(examples[messages_field], tokenize=False) + + return format_dataset + + +def instructions_formatting_function(tokenizer: AutoTokenizer): + r""" + return a callable function that takes in an "instructions" dataset and returns a formatted dataset, based on the tokenizer + apply chat template to the dataset + """ + + def format_dataset(examples): + if isinstance(examples["prompt"], list): + output_texts = [] + for i in range(len(examples["prompt"])): + converted_sample = [ + {"role": "user", "content": examples["prompt"][i]}, + {"role": "assistant", "content": examples["completion"][i]}, + ] + output_texts.append(tokenizer.apply_chat_template(converted_sample, tokenize=False)) + return output_texts + else: + converted_sample = [ + {"role": "user", "content": examples["prompt"]}, + {"role": "assistant", "content": examples["completion"]}, + ] + return tokenizer.apply_chat_template(converted_sample, tokenize=False) + + return format_dataset + + +def get_formatting_func_from_dataset(dataset: Union[Dataset, ConstantLengthDataset], tokenizer: AutoTokenizer) -> Optional[Callable]: + r""" + Finds the correct formatting function based on the dataset structure. Currently supported datasets are: + - `ChatML` with [{"role": str, "content": str}] + - `instruction` with [{"prompt": str, "completion": str}] + + Args: + dataset (Dataset): User dataset + tokenizer (AutoTokenizer): Tokenizer used for formatting + + Returns: + Callable: Formatting function if the dataset format is supported else None + """ + if isinstance(dataset, Dataset): + if "messages" in dataset.features: + if dataset.features["messages"] == FORMAT_MAPPING["chatml"]: + logging.info("Formatting dataset with chatml format") + return conversations_formatting_function(tokenizer, "messages") + if "conversations" in dataset.features: + if dataset.features["conversations"] == FORMAT_MAPPING["chatml"]: + logging.info("Formatting dataset with chatml format") + return conversations_formatting_function(tokenizer, "conversations") + elif dataset.features == FORMAT_MAPPING["instruction"]: + logging.info("Formatting dataset with instruction format") + return instructions_formatting_function(tokenizer) + + return None diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/import_utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/import_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..88a04f7d15e2cf6f87102e561aaeb859b2744b9d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/import_utils.py @@ -0,0 +1,108 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import importlib +import sys + + +if sys.version_info < (3, 8): + _is_python_greater_3_8 = False +else: + _is_python_greater_3_8 = True + + +def is_peft_available() -> bool: + return importlib.util.find_spec("peft") is not None + + +def is_unsloth_available() -> bool: + return importlib.util.find_spec("unsloth") is not None + + +def is_accelerate_greater_20_0() -> bool: + if _is_python_greater_3_8: + from importlib.metadata import version + + accelerate_version = version("accelerate") + else: + import pkg_resources + + accelerate_version = pkg_resources.get_distribution("accelerate").version + return accelerate_version >= "0.20.0" + + +def is_transformers_greater_than(version: str) -> bool: + _transformers_version = importlib.metadata.version("transformers") + return _transformers_version > version + + +def is_torch_greater_2_0() -> bool: + if _is_python_greater_3_8: + from importlib.metadata import version + + torch_version = version("torch") + else: + import pkg_resources + + torch_version = pkg_resources.get_distribution("torch").version + return torch_version >= "2.0" + + +def is_diffusers_available() -> bool: + return importlib.util.find_spec("diffusers") is not None + + +def is_bitsandbytes_available() -> bool: + import torch + + # bnb can be imported without GPU but is not usable. + return importlib.util.find_spec("bitsandbytes") is not None and torch.cuda.is_available() + + +def is_torchvision_available() -> bool: + return importlib.util.find_spec("torchvision") is not None + + +def is_rich_available() -> bool: + return importlib.util.find_spec("rich") is not None + + +def is_wandb_available() -> bool: + return importlib.util.find_spec("wandb") is not None + + +def is_xpu_available() -> bool: + if is_accelerate_greater_20_0(): + import accelerate + + return accelerate.utils.is_xpu_available() + else: + if importlib.util.find_spec("intel_extension_for_pytorch") is None: + return False + try: + import torch + + return hasattr(torch, "xpu") and torch.xpu.is_available() + except RuntimeError: + return False + + +def is_npu_available() -> bool: + """Checks if `torch_npu` is installed and potentially if a NPU is in the environment""" + if importlib.util.find_spec("torch") is None or importlib.util.find_spec("torch_npu") is None: + return False + + import torch + import torch_npu # noqa: F401 + + return hasattr(torch, "npu") and torch.npu.is_available() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ec2034553379244d67d4e16a3537e631c9d0d100 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/__init__.py @@ -0,0 +1,35 @@ +# flake8: noqa + +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from .modeling_base import PreTrainedModelWrapper, create_reference_model +from .modeling_value_head import AutoModelForCausalLMWithValueHead, AutoModelForSeq2SeqLMWithValueHead +from .utils import setup_chat_format + + +SUPPORTED_ARCHITECTURES = ( + AutoModelForCausalLMWithValueHead, + AutoModelForSeq2SeqLMWithValueHead, +) + +from ..import_utils import is_diffusers_available + + +if is_diffusers_available(): + from .modeling_sd_base import ( + DDPOPipelineOutput, + DDPOSchedulerOutput, + DDPOStableDiffusionPipeline, + DefaultDDPOStableDiffusionPipeline, + ) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_base.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_base.py new file mode 100644 index 0000000000000000000000000000000000000000..9e6c4fceb1fbd142941a539af5d74649927f4bc3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_base.py @@ -0,0 +1,640 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import json +import logging +import os +from copy import deepcopy + +import torch +import torch.nn as nn +from accelerate import PartialState +from huggingface_hub import hf_hub_download +from huggingface_hub.utils import ( + EntryNotFoundError, + HFValidationError, + LocalEntryNotFoundError, + RepositoryNotFoundError, +) +from safetensors.torch import load_file as safe_load_file +from transformers import PreTrainedModel + +from ..import_utils import is_npu_available, is_peft_available, is_transformers_greater_than, is_xpu_available + + +if is_peft_available(): + from peft import ( + PeftConfig, + PeftModel, + PeftModelForCausalLM, + PeftModelForSeq2SeqLM, + PromptLearningConfig, + get_peft_model, + prepare_model_for_kbit_training, + ) + +if is_transformers_greater_than("4.33.0"): + from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled +else: + from transformers.deepspeed import is_deepspeed_zero3_enabled + +LAYER_PATTERNS = [ + "transformer.h.{layer}", + "model.decoder.layers.{layer}", + "gpt_neox.layers.{layer}", + "model.layers.{layer}", +] + + +class PreTrainedModelWrapper(nn.Module): + r""" + A wrapper class around a (`transformers.PreTrainedModel`) to be compatible with the + (`~transformers.PreTrained`) class in order to keep some attributes and methods of the + (`~transformers.PreTrainedModel`) class. + + Attributes: + pretrained_model: (`transformers.PreTrainedModel`) + The model to be wrapped. + parent_class: (`transformers.PreTrainedModel`) + The parent class of the model to be wrapped. + supported_args: (`list`) + The list of arguments that are supported by the wrapper class. + """ + + transformers_parent_class = None + supported_args = None + supported_modules = ("v_head",) + supported_rm_modules = ("score",) + supported_pretrained_model_architectures = (PreTrainedModel) if not is_peft_available() else (PreTrainedModel, PeftModelForCausalLM, PeftModelForSeq2SeqLM) + + def __init__(self, pretrained_model=None, score_module=None, supports_rm_adapter=False, rm_adapter_name=None, **kwargs): + super().__init__() + self.pretrained_model = pretrained_model + + self.config = pretrained_model.config + self.prepare_inputs_for_generation = pretrained_model.prepare_inputs_for_generation + self.is_loaded_in_8bit = getattr(pretrained_model, "is_loaded_in_8bit", False) + self.is_loaded_in_4bit = getattr(pretrained_model, "is_loaded_in_4bit", False) + self.is_sequential_parallel = False + + if hasattr(pretrained_model, "gradient_checkpointing_disable"): + self.gradient_checkpointing_disable = pretrained_model.gradient_checkpointing_disable + + if hasattr(pretrained_model, "gradient_checkpointing_enable"): + self.gradient_checkpointing_enable = pretrained_model.gradient_checkpointing_enable + + self.supports_rm_adapter = supports_rm_adapter + self.rm_adapter_name = rm_adapter_name + self.policy_adapter_name = "default" + if score_module is not None: + self.score = score_module + + @classmethod + def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs): + r""" + Instantiates a new model from a pretrained model from `transformers`. The + pretrained model is loaded using the `from_pretrained` method of the + `transformers.PreTrainedModel` class. The arguments that are specific to the + `transformers.PreTrainedModel` class are passed along this method and filtered + out from the `kwargs` argument. + + + Args: + pretrained_model_name_or_path (`str` or `transformers.PreTrainedModel`): + The path to the pretrained model or its name. + *model_args (`list`, *optional*)): + Additional positional arguments passed along to the underlying model's + `from_pretrained` method. + **kwargs (`dict`, *optional*): + Additional keyword arguments passed along to the underlying model's + `from_pretrained` method. We also pre-process the kwargs to extract + the arguments that are specific to the `transformers.PreTrainedModel` + class and the arguments that are specific to trl models. The kwargs + also support `prepare_model_for_kbit_training` arguments from + `peft` library. + """ + if kwargs is not None: + peft_config = kwargs.pop("peft_config", None) + reward_adapter = kwargs.pop("reward_adapter", None) + reward_adapter_name = kwargs.pop("reward_adapter_name", "reward_adapter") + is_trainable = kwargs.pop("is_trainable", False) + trl_model_args, pretrained_kwargs, peft_quantization_kwargs = cls._split_kwargs(kwargs) + token = pretrained_kwargs.get("token", None) + else: + peft_config = None + is_trainable = False + trl_model_args = {} + pretrained_kwargs = {} + peft_quantization_kwargs = {} + token = None + + if reward_adapter is not None and not isinstance(reward_adapter, str): + raise ValueError("The `reward_adapter` argument should be a string representing the name of local path or the Hub id to the Reward Modeling adapter.") + + is_peft_model = False + + current_device = cls._get_current_device() + if isinstance(pretrained_model_name_or_path, str): + is_loaded_in_8bit = pretrained_kwargs["load_in_8bit"] if "load_in_8bit" in pretrained_kwargs else False + is_loaded_in_4bit = pretrained_kwargs["load_in_4bit"] if "load_in_4bit" in pretrained_kwargs else False + else: + is_loaded_in_8bit = getattr(pretrained_model_name_or_path, "is_loaded_in_8bit", False) + is_loaded_in_4bit = getattr(pretrained_model_name_or_path, "is_loaded_in_4bit", False) + + if (is_loaded_in_8bit or is_loaded_in_4bit) and "device_map" not in pretrained_kwargs: + # warn users + logging.warning( + "The `device_map` argument is not provided. We will override the device_map argument." + " to set the entire" + " model on the current device. If you want to set the model on multiple devices, please provide" + " a custom `device_map` argument." + ) + pretrained_kwargs["device_map"] = {"": current_device} + + if is_peft_available() and peft_config is not None and not isinstance(peft_config, PeftConfig): + raise ValueError("The `peft_config` argument should be an instance of `peft.PeftConfig` class.") + + # First, load the pre-trained model using the parent-class + # either `AutoModelForCausalLM` or `AutoModelForSeq2SeqLM` + if isinstance(pretrained_model_name_or_path, str): + if is_peft_available(): + try: + # If there is a trained peft adapter in the hub, load its config. + remote_adapter_config = hf_hub_download( + pretrained_model_name_or_path, + "adapter_config.json", + token=token, + ) + except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError): + remote_adapter_config = None + else: + remote_adapter_config = None + + local_adapter_present = os.path.exists(os.path.join(pretrained_model_name_or_path, "adapter_config.json")) + + if (local_adapter_present or remote_adapter_config is not None) and is_peft_available(): + if peft_config is not None: + logging.warning("`peft_config` argument ignored since a peft config file was found in " f"{pretrained_model_name_or_path}") + + # Load the trained peft adapter config + if local_adapter_present: + trained_adapter_config = PeftConfig.from_pretrained(pretrained_model_name_or_path) + else: + remote_adapter_dir = os.path.dirname(remote_adapter_config) + trained_adapter_config = PeftConfig.from_pretrained(remote_adapter_dir) + + # Load the pretrained base model + pretrained_model = cls.transformers_parent_class.from_pretrained(trained_adapter_config.base_model_name_or_path, *model_args, **pretrained_kwargs) + + # Wrap the pretrained model with the trained peft adapter + pretrained_model = PeftModel.from_pretrained(pretrained_model, pretrained_model_name_or_path, is_trainable=is_trainable) + logging.info("Trained peft adapter loaded") + else: + pretrained_model = cls.transformers_parent_class.from_pretrained(pretrained_model_name_or_path, *model_args, **pretrained_kwargs) + + if peft_config is not None: + # Initialize a new peft adapter with the given config + if is_loaded_in_8bit or is_loaded_in_4bit: + pretrained_model = prepare_model_for_kbit_training( + pretrained_model, + **peft_quantization_kwargs, + ) + pretrained_model = get_peft_model(pretrained_model, peft_config) + logging.info("peft adapter initialised") + + elif isinstance(pretrained_model_name_or_path, cls.supported_pretrained_model_architectures): + pretrained_model = pretrained_model_name_or_path + + if peft_config is not None and isinstance(pretrained_model, PreTrainedModel): + # Initialize a new peft adapter with the given config + if is_loaded_in_8bit or is_loaded_in_4bit: + pretrained_model = prepare_model_for_kbit_training( + pretrained_model, + **peft_quantization_kwargs, + ) + pretrained_model = get_peft_model(pretrained_model, peft_config) + logging.info("peft adapter initialised") + else: + raise ValueError("pretrained_model_name_or_path should be a string or a PreTrainedModel, " f"but is {type(pretrained_model_name_or_path)}") + + if is_peft_available(): + if isinstance(pretrained_model, PeftModel): + is_peft_model = True + # for backward compatibility + if hasattr(pretrained_model, "active_peft_config") and isinstance(pretrained_model.active_peft_config, PromptLearningConfig): + raise ValueError("PromptLearningConfig is not supported for PPO training.") + + # Add reward modeling adapter if specified + if not is_peft_model and reward_adapter is not None: + raise ValueError("reward_adapter can only be used with a PeftModel. ") + elif is_peft_model and reward_adapter is not None: + score_module = cls.add_and_load_reward_modeling_adapter(pretrained_model, reward_adapter, reward_adapter_name, token=token) + multi_adapter_args = { + "score_module": score_module, + "supports_rm_adapter": True, + "rm_adapter_name": reward_adapter_name, + } + else: + multi_adapter_args = {"supports_rm_adapter": False} + + # Then, create the full model by instantiating the wrapper class + model = cls(pretrained_model, **multi_adapter_args, **trl_model_args) + + # if resume_training, load the state_dict again - this is ok since the + # state_dict is removed from the model after loading it. + is_resuming_training = True + if isinstance(pretrained_model_name_or_path, str): + safe_filename = os.path.join(pretrained_model_name_or_path, "model.safetensors") + filename = os.path.join(pretrained_model_name_or_path, "pytorch_model.bin") + + sharded_index_filename = os.path.join(pretrained_model_name_or_path, "pytorch_model.bin.index.json") + safe_sharded_index_filename = os.path.join(pretrained_model_name_or_path, "model.safetensors.index.json") + is_sharded = False + use_safe = os.path.exists(safe_filename) + + if not (os.path.exists(filename) or os.path.exists(safe_filename)): + # Try with `pytorch_model.bin` + filename, files_to_download, is_sharded, is_resuming_training = cls._get_checkpoint_from_hub( + pretrained_model, + pretrained_model_name_or_path, + sharded_index_filename, + token=token, + ) + # Try with safetensors + if filename is None and files_to_download is None: + safe_filename, files_to_download, is_sharded, is_resuming_training = cls._get_checkpoint_from_hub( + pretrained_model, + pretrained_model_name_or_path, + safe_sharded_index_filename, + token=token, + model_name="model.safetensors", + model_index_name="model.safetensors.index.json", + ) + use_safe = True + else: + use_safe = False + + loading_func = safe_load_file if use_safe else torch.load + load_kwargs = {} if use_safe else {"map_location": "cpu"} + + if is_resuming_training: + if is_sharded: + # download each file and add it to the state_dict + state_dict = {} + + for shard_file in files_to_download: + filename = hf_hub_download( + pretrained_model_name_or_path, + shard_file, + token=token, + ) + state_dict.update(loading_func(filename, **load_kwargs)) + else: + state_dict = loading_func(filename if not use_safe else safe_filename, **load_kwargs) + + else: + state_dict = pretrained_model_name_or_path.state_dict() + + model.is_peft_model = is_peft_model + model.current_device = current_device + + if is_resuming_training: + model.post_init(state_dict=state_dict) + + return model + + @classmethod + def _get_checkpoint_from_hub( + cls, + pretrained_model, + pretrained_model_name_or_path, + index_filename, + token=None, + model_name="pytorch_model.bin", + model_index_name="pytorch_model.bin.index.json", + ): + files_to_download = None + filename = None + is_resuming_training = True + is_sharded = False + + try: + filename = hf_hub_download( + pretrained_model_name_or_path, + model_name, + token=token, + ) + # sharded + except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError): + if os.path.exists(index_filename): + index_file_name = index_filename + else: + try: + index_file_name = hf_hub_download( + pretrained_model_name_or_path, + model_index_name, + token=token, + ) + except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError): + # not continue training, do not have v_head weight + is_resuming_training = False + logging.warning(f"A {type(pretrained_model)} model is loaded from '{pretrained_model_name_or_path}', " f"and no v_head weight is found. This IS expected if you are not resuming PPO training.") + # load json + if is_resuming_training: + with open(index_file_name, "r") as f: + index = json.load(f) + # check filename with `v_head` or any known extra module: + files_to_download = set() + for k, v in index["weight_map"].items(): + if any([module in k for module in cls.supported_modules]): + files_to_download.add(v) + is_sharded = True + + return filename, files_to_download, is_sharded, is_resuming_training + + @classmethod + def _get_current_device(cls): + r""" + Get the current device. For GPU, we return the local process index using the `accelerate.PartialState` + object to handle corner cases when running scripts in distributed environments. + + Returns: + current_device (`Union[int, str]`): + The current device. + """ + state = PartialState() + if is_xpu_available(): + return f"xpu:{state.local_process_index}" + elif is_npu_available(): + return f"npu:{state.local_process_index}" + else: + return state.local_process_index if torch.cuda.is_available() else "cpu" + + @classmethod + def _split_kwargs(cls, kwargs): + """ + Separate the kwargs from the arguments that we support inside + `supported_args` and the ones that we don't. + """ + check_peft_kwargs = False + + if is_peft_available(): + from peft import prepare_model_for_kbit_training + + check_peft_kwargs = True + + supported_kwargs = {} + unsupported_kwargs = {} + peft_kwargs = {} + + for key, value in kwargs.items(): + if key in cls.supported_args: + supported_kwargs[key] = value + else: + unsupported_kwargs[key] = value + + if check_peft_kwargs: + if key in prepare_model_for_kbit_training.__code__.co_varnames: + peft_kwargs[key] = value + if key in unsupported_kwargs: + unsupported_kwargs.pop(key) + + return supported_kwargs, unsupported_kwargs, peft_kwargs + + @classmethod + def add_and_load_reward_modeling_adapter(cls, pretrained_model, adapter_model_id, adapter_name="reward_model_adapter", token=None): + r""" + Add and load a reward modeling adapter. This method can only be used if the + model is a `PeftModel` and if you have initialized the model with the `reward_modeling_adapter_id` + argument, pointing to the id of the reward modeling adapter. The latest needs also to contain the + score head in order to produce the reward. + """ + pretrained_model.load_adapter(adapter_model_id, adapter_name, is_trainable=False) + pretrained_model.train() + + filename = os.path.join(adapter_model_id, "adapter_model.bin") + safe_loading = False + if not os.path.exists(filename): + try: + local_filename = hf_hub_download( + adapter_model_id, + "adapter_model.bin", + token=token, + ) + except: # noqa + filename = os.path.join(adapter_model_id, "adapter_model.safetensors") + safe_loading = True + if not os.path.exists(filename): + try: + local_filename = hf_hub_download( + adapter_model_id, + "adapter_model.safetensors", + token=token, + ) + except: # noqa + raise ValueError("Could not find adapter model in the Hub, make sure you have the correct adapter model id.") + else: + local_filename = filename + else: + local_filename = filename + + loading_func = safe_load_file if safe_loading else torch.load + load_kwargs = {} if safe_loading else {"map_location": "cpu"} + + adapter_state_dict = loading_func(local_filename, **load_kwargs) + + for score_name_candidate in cls.supported_rm_modules: + if any([score_name_candidate in name for name in adapter_state_dict.keys()]): + score_name = score_name_candidate + # we have found the correct head name and can break + break + + score_dict = {} + + for name, param in adapter_state_dict.items(): + if score_name in name: + key_name = ".".join(name.split(".")[-1:]) + score_dict[key_name] = param.to(cls._get_current_device()) + + num_labels, hidden_dim = score_dict["weight"].shape + has_bias = any(["bias" in name for name in adapter_state_dict.keys()]) + + score = nn.Linear(hidden_dim, num_labels, bias=has_bias).to( + device=cls._get_current_device(), + dtype=pretrained_model.dtype, + ) + score.load_state_dict(score_dict) + for param in score.parameters(): + param.requires_grad = False + + return score + + def push_to_hub(self, *args, **kwargs): + r""" + Push the pretrained model to the hub. This method is a wrapper around + `transformers.PreTrainedModel.push_to_hub`. Please refer to the documentation + of `transformers.PreTrainedModel.push_to_hub` for more information. + + Args: + *args (`list`, *optional*): + Positional arguments passed along to the underlying model's + `push_to_hub` method. + **kwargs (`dict`, *optional*): + Keyword arguments passed along to the underlying model's + `push_to_hub` method. + """ + raise NotImplementedError + + def save_pretrained(self, *args, **kwargs): + r""" + Save the pretrained model to a directory. This method is a wrapper around + `transformers.PreTrainedModel.save_pretrained`. Please refer to the documentation + of `transformers.PreTrainedModel.save_pretrained` for more information. + + Args: + *args (`list`, *optional*): + Positional arguments passed along to the underlying model's + `save_pretrained` method. + **kwargs (`dict`, *optional*): + Keyword arguments passed along to the underlying model's + `save_pretrained` method. + """ + state_dict = kwargs.get("state_dict") + if state_dict is None: + state_dict = self.state_dict() + kwargs["state_dict"] = state_dict + + # if it is a peft model only save the `v_head` state_dict and + # pop the `state_dict` from the kwargs to avoid slient bugs with `peft` + if self.is_peft_model: + save_path = args[0] + save_path = os.path.join(save_path, "pytorch_model.bin") + torch.save(state_dict, save_path) + _ = kwargs.pop("state_dict", None) + + return self.pretrained_model.save_pretrained(*args, **kwargs) + + def state_dict(self, *args, **kwargs): + r""" + Return the state_dict of the pretrained model. + """ + raise NotImplementedError + + def post_init(self, *args, **kwargs): + r""" + Post initialization method. This method is called after the model is + instantiated and loaded from a checkpoint. It can be used to perform + additional operations such as loading the state_dict. + """ + raise NotImplementedError + + def compute_reward_score(self, input_ids, attention_mask=None, **kwargs): + r""" + Computes the reward score for a given input. The method has first to enable the adapter + and then compute the reward score. After that the model disables the reward modeling + adapter and enables the default ppo adapter again. + """ + if not self.supports_rm_adapter: + raise ValueError("This model does not support reward modeling adapter.") + + # enable rm adapter + self.pretrained_model.set_adapter(self.rm_adapter_name) + self.pretrained_model.eval() + + with torch.no_grad(): + base_model_output = self.pretrained_model( + input_ids=input_ids, + attention_mask=attention_mask, + output_hidden_states=True, + return_dict=True, + **kwargs, + ) + + last_hidden_states = base_model_output.hidden_states[-1] + scores = self.score(last_hidden_states) + + self.pretrained_model.set_adapter(self.policy_adapter_name) + self.pretrained_model.eval() + + return scores + + +def create_reference_model(model: PreTrainedModelWrapper, num_shared_layers: int = None, pattern: str = None) -> PreTrainedModelWrapper: + """ + Creates a static reference copy of a model. Note that model will be in `.eval()` mode. + + Args: + model (`PreTrainedModelWrapper`): The model to be copied. + num_shared_layers (`int`, *optional*): The number of initial layers that are shared between both models and kept frozen. + pattern (`str`, *optional*): The shared layers are selected with a string pattern + (e.g. "transformer.h.{layer}" for GPT2) and if a custom pattern is necessary it can be passed here. + + Returns + `PreTrainedModelWrapper` + """ + if is_deepspeed_zero3_enabled(): + raise ValueError("DeepSpeed ZeRO-3 is enabled and is not compatible with `create_reference_model()`. Please instantiate your reference model directly with `AutoCausalLM.from_pretrained()`.") + + parameter_names = [n for n, _ in model.named_parameters()] + ref_model = deepcopy(model) + + # if no layers are shared, return copy of model + if num_shared_layers is None: + for param_name in parameter_names: + param = ref_model.get_parameter(param_name) + param.requires_grad = False + return ref_model.eval() + + # identify layer name pattern + if pattern is not None: + pattern = pattern.format(layer=num_shared_layers) + else: + for pattern_candidate in LAYER_PATTERNS: + pattern_candidate = pattern_candidate.format(layer=num_shared_layers) + if any([pattern_candidate in name for name in parameter_names]): + pattern = pattern_candidate + break + + if pattern is None: + raise ValueError("Layer pattern could not be matched.") + + # divide parameters in shared and unshared parameter lists + shared_param_list = [] + unshared_param_list = [] + + shared_parameter = True + for name, param in model.named_parameters(): + if pattern in name: + shared_parameter = False + if shared_parameter: + shared_param_list.append(name) + else: + unshared_param_list.append(name) + + # create reference of the original parameter if they are shared + for param_name in shared_param_list: + param = model.get_parameter(param_name) + param.requires_grad = False + + ref_param = ref_model.get_parameter(param_name) # noqa + ref_param = param # noqa + + # for all other parameters just make sure they don't use gradients + for param_name in unshared_param_list: + param = ref_model.get_parameter(param_name) + param.requires_grad = False + + if pattern is not None and len(unshared_param_list) == 0: + logging.warning("Pattern passed or found, but no layers matched in the model. Check for a typo.") + + return ref_model.eval() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_sd_base.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_sd_base.py new file mode 100644 index 0000000000000000000000000000000000000000..5cf6a1d688874023421b87952f5d95db29330c12 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_sd_base.py @@ -0,0 +1,624 @@ +# Copyright 2023 DDPO-pytorch authors (Kevin Black), The HuggingFace Team, metric-space. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import contextlib +import os +import warnings +from dataclasses import dataclass +from typing import Any, Callable, Dict, List, Optional, Union + +import numpy as np +import torch +from diffusers import DDIMScheduler, StableDiffusionPipeline, UNet2DConditionModel +from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import rescale_noise_cfg +from diffusers.utils import convert_state_dict_to_diffusers + +from ..core import randn_tensor +from ..import_utils import is_peft_available + + +if is_peft_available(): + from peft import LoraConfig + from peft.utils import get_peft_model_state_dict + + +@dataclass +class DDPOPipelineOutput(object): + """ + Output class for the diffusers pipeline to be finetuned with the DDPO trainer + + Args: + images (`torch.Tensor`): + The generated images. + latents (`List[torch.Tensor]`): + The latents used to generate the images. + log_probs (`List[torch.Tensor]`): + The log probabilities of the latents. + + """ + + images: torch.Tensor + latents: torch.Tensor + log_probs: torch.Tensor + + +@dataclass +class DDPOSchedulerOutput(object): + """ + Output class for the diffusers scheduler to be finetuned with the DDPO trainer + + Args: + latents (`torch.Tensor`): + Predicted sample at the previous timestep. Shape: `(batch_size, num_channels, height, width)` + log_probs (`torch.Tensor`): + Log probability of the above mentioned sample. Shape: `(batch_size)` + """ + + latents: torch.Tensor + log_probs: torch.Tensor + + +class DDPOStableDiffusionPipeline(object): + """ + Main class for the diffusers pipeline to be finetuned with the DDPO trainer + """ + + def __call__(self, *args, **kwargs) -> DDPOPipelineOutput: + raise NotImplementedError + + def scheduler_step(self, *args, **kwargs) -> DDPOSchedulerOutput: + raise NotImplementedError + + @property + def unet(self): + """ + Returns the 2d U-Net model used for diffusion. + """ + raise NotImplementedError + + @property + def vae(self): + """ + Returns the Variational Autoencoder model used from mapping images to and from the latent space + """ + raise NotImplementedError + + @property + def tokenizer(self): + """ + Returns the tokenizer used for tokenizing text inputs + """ + raise NotImplementedError + + @property + def scheduler(self): + """ + Returns the scheduler associated with the pipeline used for the diffusion process + """ + raise NotImplementedError + + @property + def text_encoder(self): + """ + Returns the text encoder used for encoding text inputs + """ + raise NotImplementedError + + @property + def autocast(self): + """ + Returns the autocast context manager + """ + raise NotImplementedError + + def set_progress_bar_config(self, *args, **kwargs): + """ + Sets the progress bar config for the pipeline + """ + raise NotImplementedError + + def save_pretrained(self, *args, **kwargs): + """ + Saves all of the model weights + """ + raise NotImplementedError + + def get_trainable_layers(self, *args, **kwargs): + """ + Returns the trainable parameters of the pipeline + """ + raise NotImplementedError + + def save_checkpoint(self, *args, **kwargs): + """ + Light wrapper around accelerate's register_save_state_pre_hook which is run before saving state + """ + raise NotImplementedError + + def load_checkpoint(self, *args, **kwargs): + """ + Light wrapper around accelerate's register_lad_state_pre_hook which is run before loading state + """ + raise NotImplementedError + + +def _left_broadcast(input_tensor, shape): + """ + As opposed to the default direction of broadcasting (right to left), this function broadcasts + from left to right + Args: + input_tensor (`torch.FloatTensor`): is the tensor to broadcast + shape (`Tuple[int]`): is the shape to broadcast to + """ + input_ndim = input_tensor.ndim + if input_ndim > len(shape): + raise ValueError("The number of dimensions of the tensor to broadcast cannot be greater than the length of the shape to broadcast to") + return input_tensor.reshape(input_tensor.shape + (1,) * (len(shape) - input_ndim)).broadcast_to(shape) + + +def _get_variance(self, timestep, prev_timestep): + alpha_prod_t = torch.gather(self.alphas_cumprod, 0, timestep.cpu()).to(timestep.device) + alpha_prod_t_prev = torch.where( + prev_timestep.cpu() >= 0, + self.alphas_cumprod.gather(0, prev_timestep.cpu()), + self.final_alpha_cumprod, + ).to(timestep.device) + beta_prod_t = 1 - alpha_prod_t + beta_prod_t_prev = 1 - alpha_prod_t_prev + + variance = (beta_prod_t_prev / beta_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev) + + return variance + + +def scheduler_step( + self, + model_output: torch.FloatTensor, + timestep: int, + sample: torch.FloatTensor, + eta: float = 0.0, + use_clipped_model_output: bool = False, + generator=None, + prev_sample: Optional[torch.FloatTensor] = None, +) -> DDPOSchedulerOutput: + """ + + Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion + process from the learned model outputs (most often the predicted noise). + + Args: + model_output (`torch.FloatTensor`): direct output from learned diffusion model. + timestep (`int`): current discrete timestep in the diffusion chain. + sample (`torch.FloatTensor`): + current instance of sample being created by diffusion process. + eta (`float`): weight of noise for added noise in diffusion step. + use_clipped_model_output (`bool`): if `True`, compute "corrected" `model_output` from the clipped + predicted original sample. Necessary because predicted original sample is clipped to [-1, 1] when + `self.config.clip_sample` is `True`. If no clipping has happened, "corrected" `model_output` would + coincide with the one provided as input and `use_clipped_model_output` will have not effect. + generator: random number generator. + variance_noise (`torch.FloatTensor`): instead of generating noise for the variance using `generator`, we + can directly provide the noise for the variance itself. This is useful for methods such as + CycleDiffusion. (https://arxiv.org/abs/2210.05559) + + Returns: + `DDPOSchedulerOutput`: the predicted sample at the previous timestep and the log probability of the sample + """ + + if self.num_inference_steps is None: + raise ValueError("Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler") + + # See formulas (12) and (16) of DDIM paper https://arxiv.org/pdf/2010.02502.pdf + # Ideally, read DDIM paper in-detail understanding + + # Notation ( -> + # - pred_noise_t -> e_theta(x_t, t) + # - pred_original_sample -> f_theta(x_t, t) or x_0 + # - std_dev_t -> sigma_t + # - eta -> η + # - pred_sample_direction -> "direction pointing to x_t" + # - pred_prev_sample -> "x_t-1" + + # 1. get previous step value (=t-1) + prev_timestep = timestep - self.config.num_train_timesteps // self.num_inference_steps + # to prevent OOB on gather + prev_timestep = torch.clamp(prev_timestep, 0, self.config.num_train_timesteps - 1) + + # 2. compute alphas, betas + alpha_prod_t = self.alphas_cumprod.gather(0, timestep.cpu()) + alpha_prod_t_prev = torch.where( + prev_timestep.cpu() >= 0, + self.alphas_cumprod.gather(0, prev_timestep.cpu()), + self.final_alpha_cumprod, + ) + alpha_prod_t = _left_broadcast(alpha_prod_t, sample.shape).to(sample.device) + alpha_prod_t_prev = _left_broadcast(alpha_prod_t_prev, sample.shape).to(sample.device) + + beta_prod_t = 1 - alpha_prod_t + + # 3. compute predicted original sample from predicted noise also called + # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf + if self.config.prediction_type == "epsilon": + pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5) + pred_epsilon = model_output + elif self.config.prediction_type == "sample": + pred_original_sample = model_output + pred_epsilon = (sample - alpha_prod_t ** (0.5) * pred_original_sample) / beta_prod_t ** (0.5) + elif self.config.prediction_type == "v_prediction": + pred_original_sample = (alpha_prod_t**0.5) * sample - (beta_prod_t**0.5) * model_output + pred_epsilon = (alpha_prod_t**0.5) * model_output + (beta_prod_t**0.5) * sample + else: + raise ValueError(f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" " `v_prediction`") + + # 4. Clip or threshold "predicted x_0" + if self.config.thresholding: + pred_original_sample = self._threshold_sample(pred_original_sample) + elif self.config.clip_sample: + pred_original_sample = pred_original_sample.clamp(-self.config.clip_sample_range, self.config.clip_sample_range) + + # 5. compute variance: "sigma_t(η)" -> see formula (16) + # σ_t = sqrt((1 − α_t−1)/(1 − α_t)) * sqrt(1 − α_t/α_t−1) + variance = _get_variance(self, timestep, prev_timestep) + std_dev_t = eta * variance ** (0.5) + std_dev_t = _left_broadcast(std_dev_t, sample.shape).to(sample.device) + + if use_clipped_model_output: + # the pred_epsilon is always re-derived from the clipped x_0 in Glide + pred_epsilon = (sample - alpha_prod_t ** (0.5) * pred_original_sample) / beta_prod_t ** (0.5) + + # 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf + pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * pred_epsilon + + # 7. compute x_t without "random noise" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf + prev_sample_mean = alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction + + if prev_sample is not None and generator is not None: + raise ValueError("Cannot pass both generator and prev_sample. Please make sure that either `generator` or" " `prev_sample` stays `None`.") + + if prev_sample is None: + variance_noise = randn_tensor( + model_output.shape, + generator=generator, + device=model_output.device, + dtype=model_output.dtype, + ) + prev_sample = prev_sample_mean + std_dev_t * variance_noise + + # log prob of prev_sample given prev_sample_mean and std_dev_t + log_prob = -((prev_sample.detach() - prev_sample_mean) ** 2) / (2 * (std_dev_t**2)) - torch.log(std_dev_t) - torch.log(torch.sqrt(2 * torch.as_tensor(np.pi))) + # mean along all but batch dimension + log_prob = log_prob.mean(dim=tuple(range(1, log_prob.ndim))) + + return DDPOSchedulerOutput(prev_sample.type(sample.dtype), log_prob) + + +# 1. The output type for call is different as the logprobs are now returned +# 2. An extra method called `scheduler_step` is added which is used to constraint the scheduler output +@torch.no_grad() +def pipeline_step( + self, + prompt: Optional[Union[str, List[str]]] = None, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 50, + guidance_scale: float = 7.5, + negative_prompt: Optional[Union[str, List[str]]] = None, + num_images_per_prompt: Optional[int] = 1, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None, + callback_steps: int = 1, + cross_attention_kwargs: Optional[Dict[str, Any]] = None, + guidance_rescale: float = 0.0, +): + r""" + Function invoked when calling the pipeline for generation. Args: prompt (`str` or `List[str]`, *optional*): The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. instead. height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): The height in pixels of the generated image. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + guidance_scale (`float`, *optional*, defaults to 7.5): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to + [`schedulers.DDIMScheduler`], will be ignored for others. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a + plain tuple. + callback (`Callable`, *optional*): + A function that will be called every `callback_steps` steps during inference. The function will be + called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`. + callback_steps (`int`, *optional*, defaults to 1): + The frequency at which the `callback` function will be called. If not specified, the callback will be + called at every step. + cross_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py). + guidance_rescale (`float`, *optional*, defaults to 0.7): + Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are + Flawed](https://arxiv.org/pdf/2305.08891.pdf) `guidance_scale` is defined as `φ` in equation 16. of + [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). + Guidance rescale factor should fix overexposure when using zero terminal SNR. + + Examples: + + Returns: + `DDPOPipelineOutput`: The generated image, the predicted latents used to generate the image and the associated log probabilities + """ + # 0. Default height and width to unet + height = height or self.unet.config.sample_size * self.vae_scale_factor + width = width or self.unet.config.sample_size * self.vae_scale_factor + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + prompt, + height, + width, + callback_steps, + negative_prompt, + prompt_embeds, + negative_prompt_embeds, + ) + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + # 3. Encode input prompt + text_encoder_lora_scale = cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None + prompt_embeds = self._encode_prompt( + prompt, + device, + num_images_per_prompt, + do_classifier_free_guidance, + negative_prompt, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + lora_scale=text_encoder_lora_scale, + ) + + # 4. Prepare timesteps + self.scheduler.set_timesteps(num_inference_steps, device=device) + timesteps = self.scheduler.timesteps + + # 5. Prepare latent variables + num_channels_latents = self.unet.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 6. Denoising loop + num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order + all_latents = [latents] + all_log_probs = [] + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + # predict the noise residual + noise_pred = self.unet( + latent_model_input, + t, + encoder_hidden_states=prompt_embeds, + cross_attention_kwargs=cross_attention_kwargs, + return_dict=False, + )[0] + + # perform guidance + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + if do_classifier_free_guidance and guidance_rescale > 0.0: + # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf + noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale) + + # compute the previous noisy sample x_t -> x_t-1 + scheduler_output = scheduler_step(self.scheduler, noise_pred, t, latents, eta) + latents = scheduler_output.latents + log_prob = scheduler_output.log_probs + + all_latents.append(latents) + all_log_probs.append(log_prob) + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + callback(i, t, latents) + + if not output_type == "latent": + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype) + else: + image = latents + has_nsfw_concept = None + + if has_nsfw_concept is None: + do_denormalize = [True] * image.shape[0] + else: + do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept] + + image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize) + + # Offload last model to CPU + if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: + self.final_offload_hook.offload() + + return DDPOPipelineOutput(image, all_latents, all_log_probs) + + +class DefaultDDPOStableDiffusionPipeline(DDPOStableDiffusionPipeline): + def __init__(self, pretrained_model_name: str, *, pretrained_model_revision: str = "main", use_lora: bool = True): + self.sd_pipeline = StableDiffusionPipeline.from_pretrained(pretrained_model_name, revision=pretrained_model_revision) + + self.use_lora = use_lora + self.pretrained_model = pretrained_model_name + self.pretrained_revision = pretrained_model_revision + + try: + self.sd_pipeline.load_lora_weights( + pretrained_model_name, + weight_name="pytorch_lora_weights.safetensors", + revision=pretrained_model_revision, + ) + self.use_lora = True + except OSError: + if use_lora: + warnings.warn("If you are aware that the pretrained model has no lora weights to it, ignore this message. " "Otherwise please check the if `pytorch_lora_weights.safetensors` exists in the model folder.") + + self.sd_pipeline.scheduler = DDIMScheduler.from_config(self.sd_pipeline.scheduler.config) + self.sd_pipeline.safety_checker = None + + # memory optimization + self.sd_pipeline.vae.requires_grad_(False) + self.sd_pipeline.text_encoder.requires_grad_(False) + self.sd_pipeline.unet.requires_grad_(not self.use_lora) + + def __call__(self, *args, **kwargs) -> DDPOPipelineOutput: + return pipeline_step(self.sd_pipeline, *args, **kwargs) + + def scheduler_step(self, *args, **kwargs) -> DDPOSchedulerOutput: + return scheduler_step(self.sd_pipeline.scheduler, *args, **kwargs) + + @property + def unet(self): + return self.sd_pipeline.unet + + @property + def vae(self): + return self.sd_pipeline.vae + + @property + def tokenizer(self): + return self.sd_pipeline.tokenizer + + @property + def scheduler(self): + return self.sd_pipeline.scheduler + + @property + def text_encoder(self): + return self.sd_pipeline.text_encoder + + @property + def autocast(self): + return contextlib.nullcontext if self.use_lora else None + + def save_pretrained(self, output_dir): + if self.use_lora: + state_dict = convert_state_dict_to_diffusers(get_peft_model_state_dict(self.sd_pipeline.unet)) + self.sd_pipeline.save_lora_weights(save_directory=output_dir, unet_lora_layers=state_dict) + self.sd_pipeline.save_pretrained(output_dir) + + def set_progress_bar_config(self, *args, **kwargs): + self.sd_pipeline.set_progress_bar_config(*args, **kwargs) + + def get_trainable_layers(self): + if self.use_lora: + lora_config = LoraConfig( + r=4, + lora_alpha=4, + init_lora_weights="gaussian", + target_modules=["to_k", "to_q", "to_v", "to_out.0"], + ) + self.sd_pipeline.unet.add_adapter(lora_config) + + # To avoid accelerate unscaling problems in FP16. + for param in self.sd_pipeline.unet.parameters(): + # only upcast trainable parameters (LoRA) into fp32 + if param.requires_grad: + param.data = param.to(torch.float32) + return self.sd_pipeline.unet + else: + return self.sd_pipeline.unet + + def save_checkpoint(self, models, weights, output_dir): + if len(models) != 1: + raise ValueError("Given how the trainable params were set, this should be of length 1") + if self.use_lora and hasattr(models[0], "peft_config") and getattr(models[0], "peft_config", None) is not None: + state_dict = convert_state_dict_to_diffusers(get_peft_model_state_dict(models[0])) + self.sd_pipeline.save_lora_weights(save_directory=output_dir, unet_lora_layers=state_dict) + elif not self.use_lora and isinstance(models[0], UNet2DConditionModel): + models[0].save_pretrained(os.path.join(output_dir, "unet")) + else: + raise ValueError(f"Unknown model type {type(models[0])}") + + def load_checkpoint(self, models, input_dir): + if len(models) != 1: + raise ValueError("Given how the trainable params were set, this should be of length 1") + if self.use_lora: + lora_state_dict, network_alphas = self.sd_pipeline.lora_state_dict(input_dir, weight_name="pytorch_lora_weights.safetensors") + self.sd_pipeline.load_lora_into_unet(lora_state_dict, network_alphas=network_alphas, unet=models[0]) + + elif not self.use_lora and isinstance(models[0], UNet2DConditionModel): + load_model = UNet2DConditionModel.from_pretrained(input_dir, subfolder="unet") + models[0].register_to_config(**load_model.config) + models[0].load_state_dict(load_model.state_dict()) + del load_model + else: + raise ValueError(f"Unknown model type {type(models[0])}") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_value_head.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_value_head.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ca25ee3a9c5176d82ad63e71ddf0ad582d74b6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/modeling_value_head.py @@ -0,0 +1,421 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import torch +import torch.nn as nn +from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM + +from .modeling_base import PreTrainedModelWrapper + + +class ValueHead(nn.Module): + r""" + The ValueHead class implements a head for GPT2 that returns a scalar for each output token. + """ + + def __init__(self, config, **kwargs): + super().__init__() + if not hasattr(config, "summary_dropout_prob"): + summary_dropout_prob = kwargs.pop("summary_dropout_prob", 0.1) + else: + summary_dropout_prob = config.summary_dropout_prob + + self.dropout = nn.Dropout(summary_dropout_prob) if summary_dropout_prob else nn.Identity() + + # some models such as OPT have a projection layer before the word embeddings - e.g. OPT-350m + if hasattr(config, "hidden_size"): + hidden_size = config.hidden_size + if hasattr(config, "word_embed_proj_dim"): + hidden_size = config.word_embed_proj_dim + elif hasattr(config, "is_encoder_decoder"): + if config.is_encoder_decoder and hasattr(config, "decoder"): + if hasattr(config.decoder, "hidden_size"): + hidden_size = config.decoder.hidden_size + + self.summary = nn.Linear(hidden_size, 1) + + self.flatten = nn.Flatten() + + def forward(self, hidden_states): + output = self.dropout(hidden_states) + + # For now force upcast in fp32 if needed. Let's keep the + # output in fp32 for numerical stability. + if output.dtype != self.summary.weight.dtype: + output = output.to(self.summary.weight.dtype) + + output = self.summary(output) + return output + + +class AutoModelForCausalLMWithValueHead(PreTrainedModelWrapper): + r""" + An autoregressive model with a value head in addition to the language model head. + This class inherits from `~trl.PreTrainedModelWrapper` and wraps a + `transformers.PreTrainedModel` class. The wrapper class supports classic functions + such as `from_pretrained`, `push_to_hub` and `generate`. To call a method of the wrapped + model, simply manipulate the `pretrained_model` attribute of this class. + + Class attributes: + - **transformers_parent_class** (`transformers.PreTrainedModel`) -- The parent class of the wrapped model. This + should be set to `transformers.AutoModelForCausalLM` for this class. + - **lm_head_namings** (`tuple`) -- A tuple of strings that are used to identify the language model head of the + wrapped model. This is set to `("lm_head", "embed_out")` for this class but can be changed for other models + in the future + - **supported_args** (`tuple`) -- A tuple of strings that are used to identify the arguments that are supported + by the `ValueHead` class. Currently, the supported args are: + - **summary_dropout_prob** (`float`, `optional`, defaults to `None`) -- The dropout probability for the + `ValueHead` class. + - **v_head_initializer_range** (`float`, `optional`, defaults to `0.2`) -- The initializer range for the + `ValueHead` if a specific initialization strategy is selected. + - **v_head_init_strategy** (`str`, `optional`, defaults to `None`) -- The initialization strategy for the + `ValueHead`. Currently, the supported strategies are: + - **`None`** -- Initializes the weights of the `ValueHead` with a random distribution. This is the default + strategy. + - **"normal"** -- Initializes the weights of the `ValueHead` with a normal distribution. + + """ + + transformers_parent_class = AutoModelForCausalLM + lm_head_namings = ["lm_head", "embed_out"] + supported_args = ( + "summary_dropout_prob", + "v_head_initializer_range", + "v_head_init_strategy", + ) + + def __init__(self, pretrained_model, **kwargs): + r""" + Initializes the model. + + Args: + pretrained_model (`transformers.PreTrainedModel`): + The model to wrap. It should be a causal language model such as GPT2. + or any model mapped inside the `AutoModelForCausalLM` class. + kwargs (`dict`, `optional`): + Additional keyword arguments, that are passed to the `ValueHead` class. + """ + super().__init__(pretrained_model, **kwargs) + v_head_kwargs, _, _ = self._split_kwargs(kwargs) + + if not any(hasattr(self.pretrained_model, attribute) for attribute in self.lm_head_namings): + raise ValueError("The model does not have a language model head, please use a model that has one.") + + self.v_head = ValueHead(self.pretrained_model.config, **v_head_kwargs) + + self._init_weights(**v_head_kwargs) + + def _init_weights(self, **kwargs): + r""" + Initializes the weights of the value head. The default initialization strategy is random. + Users can pass a different initialization strategy by passing the `v_head_init_strategy` argument + when calling `.from_pretrained`. Supported strategies are: + - `normal`: initializes the weights with a normal distribution. + + Args: + **kwargs (`dict`, `optional`): + Additional keyword arguments, that are passed to the `ValueHead` class. These arguments + can contain the `v_head_init_strategy` argument as well as the `v_head_initializer_range` + argument. + """ + initializer_range = kwargs.pop("v_head_initializer_range", 0.2) + # random init by default + init_strategy = kwargs.pop("v_head_init_strategy", None) + if init_strategy is None: + # do nothing + pass + elif init_strategy == "normal": + self.v_head.summary.weight.data.normal_(mean=0.0, std=initializer_range) + self.v_head.summary.bias.data.zero_() + + def forward( + self, + input_ids=None, + past_key_values=None, + attention_mask=None, + **kwargs, + ): + r""" + Applies a forward pass to the wrapped model and returns the logits of the value head. + + Args: + input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): + Indices of input sequence tokens in the vocabulary. + past_key_values (`tuple(tuple(torch.FloatTensor))`, `optional`): + Contains pre-computed hidden-states (key and values in the attention blocks) as computed by the model + (see `past_key_values` input) to speed up sequential decoding. + attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + kwargs (`dict`, `optional`): + Additional keyword arguments, that are passed to the wrapped model. + """ + kwargs["output_hidden_states"] = True # this had already been set in the LORA / PEFT examples + kwargs["past_key_values"] = past_key_values + + if self.is_peft_model and self.pretrained_model.active_peft_config.peft_type == "PREFIX_TUNING": + kwargs.pop("past_key_values") + + base_model_output = self.pretrained_model( + input_ids=input_ids, + attention_mask=attention_mask, + **kwargs, + ) + + last_hidden_state = base_model_output.hidden_states[-1] + lm_logits = base_model_output.logits + loss = base_model_output.loss + + if last_hidden_state.device != self.v_head.summary.weight.device: + last_hidden_state = last_hidden_state.to(self.v_head.summary.weight.device) + + value = self.v_head(last_hidden_state).squeeze(-1) + + # force upcast in fp32 if logits are in half-precision + if lm_logits.dtype != torch.float32: + lm_logits = lm_logits.float() + + return (lm_logits, loss, value) + + def generate(self, *args, **kwargs): + r""" + A simple wrapper around the `generate` method of the wrapped model. + Please refer to the [`generate`](https://huggingface.co/docs/transformers/internal/generation_utils) + method of the wrapped model for more information about the supported arguments. + + Args: + *args (`list`, *optional*): + Positional arguments passed to the `generate` method of the wrapped model. + **kwargs (`dict`, *optional*): + Keyword arguments passed to the `generate` method of the wrapped model. + """ + return self.pretrained_model.generate(*args, **kwargs) + + def state_dict(self, *args, **kwargs): + r""" + Returns the state dictionary of the model. We add the state dictionary of the value head + to the state dictionary of the wrapped model by prepending the key with `v_head.`. + """ + if not self.is_peft_model: + pretrained_model_state_dict = self.pretrained_model.state_dict(*args, **kwargs) + else: + # if it is a peft model, only save the v_head + pretrained_model_state_dict = {} + + v_head_state_dict = self.v_head.state_dict(*args, **kwargs) + for k, v in v_head_state_dict.items(): + pretrained_model_state_dict[f"v_head.{k}"] = v + return pretrained_model_state_dict + + def push_to_hub(self, *args, **kwargs): + setattr(self.pretrained_model, "v_head", self.v_head) + + return self.pretrained_model.push_to_hub(*args, **kwargs) + + def post_init(self, state_dict): + r""" + We add the state dictionary of the value head to the state dictionary of the wrapped model + by prepending the key with `v_head.`. This function removes the `v_head.` prefix from the + keys of the value head state dictionary. + """ + for k in list(state_dict.keys()): + if "v_head." in k: + state_dict[k.replace("v_head.", "")] = state_dict.pop(k) + self.v_head.load_state_dict(state_dict, strict=False) + del state_dict + + if hasattr(self.pretrained_model, "hf_device_map"): + if "cpu" in self.pretrained_model.hf_device_map.values() or "disk" in self.pretrained_model.hf_device_map.values(): + raise ValueError("The model is offloaded on CPU or disk - CPU & disk offloading is not supported for ValueHead models.") + + first_device = list(set(self.pretrained_model.hf_device_map.values()))[0] + + self.v_head = self.v_head.to(first_device) + + def set_device_hook(module, input, outputs): + new_output = () + for output in outputs: + if isinstance(output, torch.Tensor): + new_output += (output.to(first_device),) + else: + new_output += (output,) + return new_output + + self.register_forward_hook(set_device_hook) + + self.is_sequential_parallel = True + + +class AutoModelForSeq2SeqLMWithValueHead(PreTrainedModelWrapper): + r""" + A seq2seq model with a value head in addition to the language model head. + This class inherits from `~trl.PreTrainedModelWrapper` and wraps a + `transformers.PreTrainedModel` class. The wrapper class supports classic functions + such as `from_pretrained` and `push_to_hub` and also provides some additional + functionalities such as `generate`. + + Args: + pretrained_model (`transformers.PreTrainedModel`): + The model to wrap. It should be a causal language model such as GPT2. + or any model mapped inside the `AutoModelForSeq2SeqLM` class. + kwargs: + Additional keyword arguments passed along to the `ValueHead` class. + """ + + transformers_parent_class = AutoModelForSeq2SeqLM + lm_head_namings = ["lm_head", "embed_out", "output_projection"] + supported_args = ( + "summary_dropout_prob", + "v_head_initializer_range", + "v_head_init_strategy", + ) + + def __init__(self, pretrained_model, **kwargs): + super().__init__(pretrained_model, **kwargs) + v_head_kwargs, _, _ = self._split_kwargs(kwargs) + self.is_encoder_decoder = True + + if not self._has_lm_head(): + raise ValueError("The model does not have a language model head, please use a model that has one.") + + self.v_head = ValueHead(self.pretrained_model.config, **v_head_kwargs) + + self._init_weights(**v_head_kwargs) + + def _has_lm_head(self): + # check module names of all modules inside `pretrained_model` to find the language model head + for name, module in self.pretrained_model.named_modules(): + if any(attribute in name for attribute in self.lm_head_namings): + return True + return False + + def post_init(self, state_dict): + r""" + We add the state dictionary of the value head to the state dictionary of the wrapped model + by prepending the key with `v_head.`. This function removes the `v_head.` prefix from the + keys of the value head state dictionary. + """ + for k in list(state_dict.keys()): + if "v_head." in k: + state_dict[k.replace("v_head.", "")] = state_dict.pop(k) + self.v_head.load_state_dict(state_dict, strict=False) + del state_dict + + if hasattr(self.pretrained_model, "hf_device_map"): + if "cpu" in self.pretrained_model.hf_device_map.values() or "disk" in self.pretrained_model.hf_device_map.values(): + raise ValueError("The model is offloaded on CPU or disk - CPU & disk offloading is not supported for ValueHead models.") + + # get the lm_head device + for name, module in self.pretrained_model.named_modules(): + if any(attribute in name for attribute in self.lm_head_namings): + lm_head_device = module.weight.device + break + + # put v_head on the same device as the lm_head to avoid issues + self.v_head = self.v_head.to(lm_head_device) + + def set_device_hook(module, input, outputs): + r""" + A hook that sets the device of the output of the model to the device of the first + parameter of the model. + + Args: + module (`nn.Module`): + The module to which the hook is attached. + input (`tuple`): + The input to the module. + outputs (`tuple`): + The output of the module. + """ + new_output = () + for output in outputs: + if isinstance(output, torch.Tensor): + new_output += (output.to(lm_head_device),) + else: + new_output += (output,) + return new_output + + self.register_forward_hook(set_device_hook) + self.is_sequential_parallel = True + + def state_dict(self, *args, **kwargs): + r""" + Returns the state dictionary of the model. We add the state dictionary of the value head + to the state dictionary of the wrapped model by prepending the key with `v_head.`. + """ + if not self.is_peft_model: + pretrained_model_state_dict = self.pretrained_model.state_dict(*args, **kwargs) + else: + # if it is a peft model, only save the v_head + pretrained_model_state_dict = {} + + v_head_state_dict = self.v_head.state_dict(*args, **kwargs) + for k, v in v_head_state_dict.items(): + pretrained_model_state_dict[f"v_head.{k}"] = v + return pretrained_model_state_dict + + def push_to_hub(self, *args, **kwargs): + setattr(self.pretrained_model, "v_head", self.v_head) + + return self.pretrained_model.push_to_hub(*args, **kwargs) + + def _init_weights(self, **kwargs): + r""" + We initialize the weights of the value head. + """ + initializer_range = kwargs.pop("v_head_initializer_range", 0.2) + # random init by default + init_strategy = kwargs.pop("v_head_init_strategy", None) + if init_strategy is None: + # do nothing + pass + elif init_strategy == "normal": + self.v_head.summary.weight.data.normal_(mean=0.0, std=initializer_range) + self.v_head.summary.bias.data.zero_() + + def forward( + self, + input_ids=None, + past_key_values=None, + attention_mask=None, + **kwargs, + ): + kwargs["past_key_values"] = past_key_values + if self.is_peft_model and self.pretrained_model.active_peft_config.peft_type == "PREFIX_TUNING": + kwargs.pop("past_key_values") + + base_model_output = self.pretrained_model( + input_ids=input_ids, + attention_mask=attention_mask, + output_hidden_states=True, # We force the model to output hidden states + **kwargs, + ) + + last_hidden_state = base_model_output.decoder_hidden_states[-1] + lm_logits = base_model_output.logits + loss = base_model_output.loss + + value = self.v_head(last_hidden_state).squeeze(-1) + + # force upcast in fp32 if logits are in half-precision + if lm_logits.dtype != torch.float32: + lm_logits = lm_logits.float() + + return (lm_logits, loss, value) + + def generate(self, *args, **kwargs): + r""" + We call `generate` on the wrapped model. + """ + return self.pretrained_model.generate(*args, **kwargs) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d9caf757fdaf734e9dce205ccd9465caa2ba2601 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/models/utils.py @@ -0,0 +1,83 @@ +from dataclasses import dataclass +from typing import Literal, Optional, Tuple + +from transformers import PreTrainedModel, PreTrainedTokenizer + + +# TODO: Add Abstract Base Class if more formats are added +@dataclass +class ChatMlSpecialTokens: + """Dataclass for special tokens used in ChatML, including system, user, assistant, bos, eos, and pad tokens.""" + + bos_token: str = "<|im_start|>" + eos_token: str = "<|im_end|>" + pad_token: str = "<|im_end|>" + + @property + def system(self): + return f"{self.bos_token}system" + + @property + def user(self): + return f"{self.bos_token}user" + + @property + def assistant(self): + return f"{self.bos_token}assistant" + + @property + def chat_template(self): + return ( + "{% for message in messages %}" + f"{{{{'{self.bos_token}' + message['role'] + '\n' + message['content'] + '{self.eos_token}' + '\n'}}}}" + "{% endfor %}" + "{% if add_generation_prompt %}" + f"{{{{ '{self.assistant}\n' }}}}" + "{% endif %}" + ) + + +FORMAT_MAPPING = {"chatml": ChatMlSpecialTokens} + + +def setup_chat_format( + model: PreTrainedModel, + tokenizer: PreTrainedTokenizer, + format: Optional[Literal["chatml"]] = "chatml", + resize_to_multiple_of: Optional[int] = None, +) -> Tuple[PreTrainedModel, PreTrainedTokenizer]: + """ + Setup chat format by adding special tokens to the tokenizer, setting the correct format, and extending the embedding layer of the model based on the new special tokens. + + Args: + model (`~transformers.PreTrainedModel`): The model to be modified. + tokenizer (`~transformers.PreTrainedTokenizer`): The tokenizer to be modified. + format (`Optional[Literal["chatml"]]`): The format to be set. Defaults to "chatml". + resize_to_multiple_of (`Optional[int]`): Number to resize the embedding layer to. Defaults to None. + Returns: + model (`~transformers.PreTrainedModel`): The modified model. + tokenizer (`~transformers.PreTrainedTokenizer`): The modified tokenizer. + """ + # check if format available and retrieve + if format not in FORMAT_MAPPING: + raise ValueError(f"Format {format} not available. Please use one of {FORMAT_MAPPING.keys()}") + + chat_format = FORMAT_MAPPING[format]() + + # set special tokens and them + tokenizer.eos_token = chat_format.eos_token + tokenizer.pad_token = chat_format.pad_token + tokenizer.bos_token = chat_format.bos_token + tokenizer.add_special_tokens({"additional_special_tokens": [chat_format.bos_token, chat_format.eos_token]}) + # set chat format for tokenizer + tokenizer.chat_template = chat_format.chat_template + + # resize embedding layer to a multiple of 64, https://x.com/karpathy/status/1621578354024677377 + model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=resize_to_multiple_of if resize_to_multiple_of is not None else None) + # Make sure to update the generation config to use the new eos & bos token + if getattr(model, "generation_config", None) is not None: + model.generation_config.bos_token_id = tokenizer.bos_token_id + model.generation_config.eos_token_id = tokenizer.eos_token_id + model.generation_config.pad_token_id = tokenizer.pad_token_id + + return model, tokenizer diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d354601960b36b654710449677e1804729281c67 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/__init__.py @@ -0,0 +1,46 @@ +# flake8: noqa + +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# There is a circular import in the PPOTrainer if we let isort sort these +# isort: off +from .utils import ( + AdaptiveKLController, + FixedKLController, + ConstantLengthDataset, + DataCollatorForCompletionOnlyLM, + RunningMoments, + disable_dropout_in_model, + peft_module_casting_to_bf16, +) + +# isort: on + +from ..import_utils import is_diffusers_available +from .base import BaseTrainer +from .ddpo_config import DDPOConfig + + +if is_diffusers_available(): + from .ddpo_trainer import DDPOTrainer + +from .dpo_trainer import DPOTrainer +from .iterative_sft_trainer import IterativeSFTTrainer +from .model_config import ModelConfig +from .ppo_config import PPOConfig +from .ppo_trainer import PPOTrainer +from .reward_config import RewardConfig +from .reward_trainer import RewardTrainer, compute_accuracy +from .sft_trainer import SFTTrainer diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/base.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/base.py new file mode 100644 index 0000000000000000000000000000000000000000..f0314cb987fcf5a520ed1ab1ad0a7eb107f18acc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/base.py @@ -0,0 +1,46 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from huggingface_hub import PyTorchModelHubMixin + + +class BaseTrainer(PyTorchModelHubMixin): + r""" + Base class for all trainers - this base class implements the basic functions that we + need for a trainer. + + The trainer needs to have the following functions: + - step: takes in a batch of data and performs a step of training + - loss: takes in a batch of data and returns the loss + - compute_rewards: takes in a batch of data and returns the rewards + - _build_models_and_tokenizer: builds the models and tokenizer + - _build_dataset: builds the dataset + Each user is expected to implement their own trainer class that inherits from this base + if they want to use a new training algorithm. + """ + + def __init__(self, config): + self.config = config + + def step(self, *args): + raise NotImplementedError("Not implemented") + + def loss(self, *args): + raise NotImplementedError("Not implemented") + + def compute_rewards(self, *args): + raise NotImplementedError("Not implemented") + + def _save_pretrained(self, save_directory): + raise NotImplementedError("Not implemented") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ddpo_config.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ddpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..2c910950fd9caada26df4d4a0bc0accff55f687d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ddpo_config.py @@ -0,0 +1,115 @@ +import os +import sys +import warnings +from dataclasses import dataclass, field +from typing import Literal, Optional + +from ..core import flatten_dict +from ..import_utils import is_bitsandbytes_available, is_torchvision_available + + +@dataclass +class DDPOConfig: + """ + Configuration class for DDPOTrainer + """ + + # common parameters + exp_name: str = os.path.basename(sys.argv[0])[: -len(".py")] + """the name of this experiment (by default is the file name without the extension name)""" + run_name: Optional[str] = "" + """Run name for wandb logging and checkpoint saving.""" + seed: int = 0 + """Seed value for random generations""" + log_with: Optional[Literal["wandb", "tensorboard"]] = None + """Log with either 'wandb' or 'tensorboard', check https://huggingface.co/docs/accelerate/usage_guides/tracking for more details""" + tracker_kwargs: dict = field(default_factory=dict) + """Keyword arguments for the tracker (e.g. wandb_project)""" + accelerator_kwargs: dict = field(default_factory=dict) + """Keyword arguments for the accelerator""" + project_kwargs: dict = field(default_factory=dict) + """Keyword arguments for the accelerator project config (e.g. `logging_dir`)""" + tracker_project_name: str = "trl" + """Name of project to use for tracking""" + logdir: str = "logs" + """Top-level logging directory for checkpoint saving.""" + + # hyperparameters + num_epochs: int = 100 + """Number of epochs to train.""" + save_freq: int = 1 + """Number of epochs between saving model checkpoints.""" + num_checkpoint_limit: int = 5 + """Number of checkpoints to keep before overwriting old ones.""" + mixed_precision: str = "fp16" + """Mixed precision training.""" + allow_tf32: bool = True + """Allow tf32 on Ampere GPUs.""" + resume_from: Optional[str] = "" + """Resume training from a checkpoint.""" + sample_num_steps: int = 50 + """Number of sampler inference steps.""" + sample_eta: float = 1.0 + """Eta parameter for the DDIM sampler.""" + sample_guidance_scale: float = 5.0 + """Classifier-free guidance weight.""" + sample_batch_size: int = 1 + """Batch size (per GPU!) to use for sampling.""" + sample_num_batches_per_epoch: int = 2 + """Number of batches to sample per epoch.""" + train_batch_size: int = 1 + """Batch size (per GPU!) to use for training.""" + train_use_8bit_adam: bool = False + """Whether to use the 8bit Adam optimizer from bitsandbytes.""" + train_learning_rate: float = 3e-4 + """Learning rate.""" + train_adam_beta1: float = 0.9 + """Adam beta1.""" + train_adam_beta2: float = 0.999 + """Adam beta2.""" + train_adam_weight_decay: float = 1e-4 + """Adam weight decay.""" + train_adam_epsilon: float = 1e-8 + """Adam epsilon.""" + train_gradient_accumulation_steps: int = 1 + """Number of gradient accumulation steps.""" + train_max_grad_norm: float = 1.0 + """Maximum gradient norm for gradient clipping.""" + train_num_inner_epochs: int = 1 + """Number of inner epochs per outer epoch.""" + train_cfg: bool = True + """Whether or not to use classifier-free guidance during training.""" + train_adv_clip_max: float = 5 + """Clip advantages to the range.""" + train_clip_range: float = 1e-4 + """The PPO clip range.""" + train_timestep_fraction: float = 1.0 + """The fraction of timesteps to train on.""" + per_prompt_stat_tracking: bool = False + """Whether to track statistics for each prompt separately.""" + per_prompt_stat_tracking_buffer_size: int = 16 + """Number of reward values to store in the buffer for each prompt.""" + per_prompt_stat_tracking_min_count: int = 16 + """The minimum number of reward values to store in the buffer.""" + async_reward_computation: bool = False + """Whether to compute rewards asynchronously.""" + max_workers: int = 2 + """The maximum number of workers to use for async reward computation.""" + negative_prompts: Optional[str] = "" + """Comma-separated list of prompts to use as negative examples.""" + + def to_dict(self): + output_dict = {} + for key, value in self.__dict__.items(): + output_dict[key] = value + return flatten_dict(output_dict) + + def __post_init__(self): + if self.log_with not in ["wandb", "tensorboard"]: + warnings.warn(("Accelerator tracking only supports image logging if `log_with` is set to 'wandb' or 'tensorboard'.")) + + if self.log_with == "wandb" and not is_torchvision_available(): + warnings.warn("Wandb image logging requires torchvision to be installed") + + if self.train_use_8bit_adam and not is_bitsandbytes_available(): + raise ImportError("You need to install bitsandbytes to use 8bit Adam. " "You can install it with `pip install bitsandbytes`.") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ddpo_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ddpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..f1f897aae232c29d169b901fb201c6ed65832447 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ddpo_trainer.py @@ -0,0 +1,604 @@ +# Copyright 2023 DDPO-pytorch authors (Kevin Black), metric-space, The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import warnings +from collections import defaultdict +from concurrent import futures +from typing import Any, Callable, Optional, Tuple +from warnings import warn + +import torch +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from huggingface_hub import whoami + +from ..models import DDPOStableDiffusionPipeline +from . import BaseTrainer, DDPOConfig +from .utils import PerPromptStatTracker + + +logger = get_logger(__name__) + + +MODEL_CARD_TEMPLATE = """--- +license: apache-2.0 +tags: +- trl +- ddpo +- diffusers +- reinforcement-learning +- text-to-image +- stable-diffusion +--- + +# {model_name} + +This is a diffusion model that has been fine-tuned with reinforcement learning to + guide the model outputs according to a value, function, or human feedback. The model can be used for image generation conditioned with text. + +""" + + +class DDPOTrainer(BaseTrainer): + """ + The DDPOTrainer uses Deep Diffusion Policy Optimization to optimise diffusion models. + Note, this trainer is heavily inspired by the work here: https://github.com/kvablack/ddpo-pytorch + As of now only Stable Diffusion based pipelines are supported + + Attributes: + **config** (`DDPOConfig`) -- Configuration object for DDPOTrainer. Check the documentation of `PPOConfig` for more + details. + **reward_function** (Callable[[torch.Tensor, Tuple[str], Tuple[Any]], torch.Tensor]) -- Reward function to be used + **prompt_function** (Callable[[], Tuple[str, Any]]) -- Function to generate prompts to guide model + **sd_pipeline** (`DDPOStableDiffusionPipeline`) -- Stable Diffusion pipeline to be used for training. + **image_samples_hook** (Optional[Callable[[Any, Any, Any], Any]]) -- Hook to be called to log images + """ + + _tag_names = ["trl", "ddpo"] + + def __init__( + self, + config: DDPOConfig, + reward_function: Callable[[torch.Tensor, Tuple[str], Tuple[Any]], torch.Tensor], + prompt_function: Callable[[], Tuple[str, Any]], + sd_pipeline: DDPOStableDiffusionPipeline, + image_samples_hook: Optional[Callable[[Any, Any, Any], Any]] = None, + ): + if image_samples_hook is None: + warn("No image_samples_hook provided; no images will be logged") + + self.prompt_fn = prompt_function + self.reward_fn = reward_function + self.config = config + self.image_samples_callback = image_samples_hook + + accelerator_project_config = ProjectConfiguration(**self.config.project_kwargs) + + if self.config.resume_from: + self.config.resume_from = os.path.normpath(os.path.expanduser(self.config.resume_from)) + if "checkpoint_" not in os.path.basename(self.config.resume_from): + # get the most recent checkpoint in this directory + checkpoints = list( + filter( + lambda x: "checkpoint_" in x, + os.listdir(self.config.resume_from), + ) + ) + if len(checkpoints) == 0: + raise ValueError(f"No checkpoints found in {self.config.resume_from}") + checkpoint_numbers = sorted([int(x.split("_")[-1]) for x in checkpoints]) + self.config.resume_from = os.path.join( + self.config.resume_from, + f"checkpoint_{checkpoint_numbers[-1]}", + ) + + accelerator_project_config.iteration = checkpoint_numbers[-1] + 1 + + # number of timesteps within each trajectory to train on + self.num_train_timesteps = int(self.config.sample_num_steps * self.config.train_timestep_fraction) + + self.accelerator = Accelerator( + log_with=self.config.log_with, + mixed_precision=self.config.mixed_precision, + project_config=accelerator_project_config, + # we always accumulate gradients across timesteps; we want config.train.gradient_accumulation_steps to be the + # number of *samples* we accumulate across, so we need to multiply by the number of training timesteps to get + # the total number of optimizer steps to accumulate across. + gradient_accumulation_steps=self.config.train_gradient_accumulation_steps * self.num_train_timesteps, + **self.config.accelerator_kwargs, + ) + + is_okay, message = self._config_check() + if not is_okay: + raise ValueError(message) + + is_using_tensorboard = config.log_with is not None and config.log_with == "tensorboard" + + if self.accelerator.is_main_process: + self.accelerator.init_trackers( + self.config.tracker_project_name, + config=dict(ddpo_trainer_config=config.to_dict()) if not is_using_tensorboard else config.to_dict(), + init_kwargs=self.config.tracker_kwargs, + ) + + logger.info(f"\n{config}") + + set_seed(self.config.seed, device_specific=True) + + self.sd_pipeline = sd_pipeline + + self.sd_pipeline.set_progress_bar_config( + position=1, + disable=not self.accelerator.is_local_main_process, + leave=False, + desc="Timestep", + dynamic_ncols=True, + ) + + # For mixed precision training we cast all non-trainable weights (vae, non-lora text_encoder and non-lora unet) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + if self.accelerator.mixed_precision == "fp16": + inference_dtype = torch.float16 + elif self.accelerator.mixed_precision == "bf16": + inference_dtype = torch.bfloat16 + else: + inference_dtype = torch.float32 + + self.sd_pipeline.vae.to(self.accelerator.device, dtype=inference_dtype) + self.sd_pipeline.text_encoder.to(self.accelerator.device, dtype=inference_dtype) + self.sd_pipeline.unet.to(self.accelerator.device, dtype=inference_dtype) + + trainable_layers = self.sd_pipeline.get_trainable_layers() + + self.accelerator.register_save_state_pre_hook(self._save_model_hook) + self.accelerator.register_load_state_pre_hook(self._load_model_hook) + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if self.config.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + self.optimizer = self._setup_optimizer(trainable_layers.parameters() if not isinstance(trainable_layers, list) else trainable_layers) + + self.neg_prompt_embed = self.sd_pipeline.text_encoder( + self.sd_pipeline.tokenizer( + [""] if self.config.negative_prompts is None else self.config.negative_prompts, + return_tensors="pt", + padding="max_length", + truncation=True, + max_length=self.sd_pipeline.tokenizer.model_max_length, + ).input_ids.to(self.accelerator.device) + )[0] + + if config.per_prompt_stat_tracking: + self.stat_tracker = PerPromptStatTracker( + config.per_prompt_stat_tracking_buffer_size, + config.per_prompt_stat_tracking_min_count, + ) + + # NOTE: for some reason, autocast is necessary for non-lora training but for lora training it isn't necessary and it uses + # more memory + self.autocast = self.sd_pipeline.autocast or self.accelerator.autocast + + if hasattr(self.sd_pipeline, "use_lora") and self.sd_pipeline.use_lora: + unet, self.optimizer = self.accelerator.prepare(trainable_layers, self.optimizer) + self.trainable_layers = list(filter(lambda p: p.requires_grad, unet.parameters())) + else: + self.trainable_layers, self.optimizer = self.accelerator.prepare(trainable_layers, self.optimizer) + + if self.config.async_reward_computation: + self.executor = futures.ThreadPoolExecutor(max_workers=config.max_workers) + + if config.resume_from: + logger.info(f"Resuming from {config.resume_from}") + self.accelerator.load_state(config.resume_from) + self.first_epoch = int(config.resume_from.split("_")[-1]) + 1 + else: + self.first_epoch = 0 + + def compute_rewards(self, prompt_image_pairs, is_async=False): + if not is_async: + rewards = [] + for images, prompts, prompt_metadata in prompt_image_pairs: + reward, reward_metadata = self.reward_fn(images, prompts, prompt_metadata) + rewards.append( + ( + torch.as_tensor(reward, device=self.accelerator.device), + reward_metadata, + ) + ) + else: + rewards = self.executor.map(lambda x: self.reward_fn(*x), prompt_image_pairs) + rewards = [(torch.as_tensor(reward.result(), device=self.accelerator.device), reward_metadata.result()) for reward, reward_metadata in rewards] + + return zip(*rewards) + + def step(self, epoch: int, global_step: int): + """ + Perform a single step of training. + + Args: + epoch (int): The current epoch. + global_step (int): The current global step. + + Side Effects: + - Model weights are updated + - Logs the statistics to the accelerator trackers. + - If `self.image_samples_callback` is not None, it will be called with the prompt_image_pairs, global_step, and the accelerator tracker. + + Returns: + global_step (int): The updated global step. + + """ + samples, prompt_image_data = self._generate_samples( + iterations=self.config.sample_num_batches_per_epoch, + batch_size=self.config.sample_batch_size, + ) + + # collate samples into dict where each entry has shape (num_batches_per_epoch * sample.batch_size, ...) + samples = {k: torch.cat([s[k] for s in samples]) for k in samples[0].keys()} + rewards, rewards_metadata = self.compute_rewards(prompt_image_data, is_async=self.config.async_reward_computation) + + for i, image_data in enumerate(prompt_image_data): + image_data.extend([rewards[i], rewards_metadata[i]]) + + if self.image_samples_callback is not None: + self.image_samples_callback(prompt_image_data, global_step, self.accelerator.trackers[0]) + + rewards = torch.cat(rewards) + rewards = self.accelerator.gather(rewards).cpu().numpy() + + self.accelerator.log( + { + "reward": rewards, + "epoch": epoch, + "reward_mean": rewards.mean(), + "reward_std": rewards.std(), + }, + step=global_step, + ) + + if self.config.per_prompt_stat_tracking: + # gather the prompts across processes + prompt_ids = self.accelerator.gather(samples["prompt_ids"]).cpu().numpy() + prompts = self.sd_pipeline.tokenizer.batch_decode(prompt_ids, skip_special_tokens=True) + advantages = self.stat_tracker.update(prompts, rewards) + else: + advantages = (rewards - rewards.mean()) / (rewards.std() + 1e-8) + + # ungather advantages; keep the entries corresponding to the samples on this process + samples["advantages"] = torch.as_tensor(advantages).reshape(self.accelerator.num_processes, -1)[self.accelerator.process_index].to(self.accelerator.device) + + del samples["prompt_ids"] + + total_batch_size, num_timesteps = samples["timesteps"].shape + + for inner_epoch in range(self.config.train_num_inner_epochs): + # shuffle samples along batch dimension + perm = torch.randperm(total_batch_size, device=self.accelerator.device) + samples = {k: v[perm] for k, v in samples.items()} + + # shuffle along time dimension independently for each sample + # still trying to understand the code below + perms = torch.stack([torch.randperm(num_timesteps, device=self.accelerator.device) for _ in range(total_batch_size)]) + + for key in ["timesteps", "latents", "next_latents", "log_probs"]: + samples[key] = samples[key][ + torch.arange(total_batch_size, device=self.accelerator.device)[:, None], + perms, + ] + + original_keys = samples.keys() + original_values = samples.values() + # rebatch them as user defined train_batch_size is different from sample_batch_size + reshaped_values = [v.reshape(-1, self.config.train_batch_size, *v.shape[1:]) for v in original_values] + + # Transpose the list of original values + transposed_values = zip(*reshaped_values) + # Create new dictionaries for each row of transposed values + samples_batched = [dict(zip(original_keys, row_values)) for row_values in transposed_values] + + self.sd_pipeline.unet.train() + global_step = self._train_batched_samples(inner_epoch, epoch, global_step, samples_batched) + # ensure optimization step at the end of the inner epoch + if not self.accelerator.sync_gradients: + raise ValueError("Optimization step should have been performed by this point. Please check calculated gradient accumulation settings.") + + if epoch != 0 and epoch % self.config.save_freq == 0 and self.accelerator.is_main_process: + self.accelerator.save_state() + + return global_step + + def calculate_loss(self, latents, timesteps, next_latents, log_probs, advantages, embeds): + """ + Calculate the loss for a batch of an unpacked sample + + Args: + latents (torch.Tensor): + The latents sampled from the diffusion model, shape: [batch_size, num_channels_latents, height, width] + timesteps (torch.Tensor): + The timesteps sampled from the diffusion model, shape: [batch_size] + next_latents (torch.Tensor): + The next latents sampled from the diffusion model, shape: [batch_size, num_channels_latents, height, width] + log_probs (torch.Tensor): + The log probabilities of the latents, shape: [batch_size] + advantages (torch.Tensor): + The advantages of the latents, shape: [batch_size] + embeds (torch.Tensor): + The embeddings of the prompts, shape: [2*batch_size or batch_size, ...] + Note: the "or" is because if train_cfg is True, the expectation is that negative prompts are concatenated to the embeds + + Returns: + loss (torch.Tensor), approx_kl (torch.Tensor), clipfrac (torch.Tensor) + (all of these are of shape (1,)) + """ + with self.autocast(): + if self.config.train_cfg: + noise_pred = self.sd_pipeline.unet( + torch.cat([latents] * 2), + torch.cat([timesteps] * 2), + embeds, + ).sample + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + self.config.sample_guidance_scale * (noise_pred_text - noise_pred_uncond) + else: + noise_pred = self.sd_pipeline.unet( + latents, + timesteps, + embeds, + ).sample + # compute the log prob of next_latents given latents under the current model + + scheduler_step_output = self.sd_pipeline.scheduler_step( + noise_pred, + timesteps, + latents, + eta=self.config.sample_eta, + prev_sample=next_latents, + ) + + log_prob = scheduler_step_output.log_probs + + advantages = torch.clamp( + advantages, + -self.config.train_adv_clip_max, + self.config.train_adv_clip_max, + ) + + ratio = torch.exp(log_prob - log_probs) + + loss = self.loss(advantages, self.config.train_clip_range, ratio) + + approx_kl = 0.5 * torch.mean((log_prob - log_probs) ** 2) + + clipfrac = torch.mean((torch.abs(ratio - 1.0) > self.config.train_clip_range).float()) + + return loss, approx_kl, clipfrac + + def loss( + self, + advantages: torch.Tensor, + clip_range: float, + ratio: torch.Tensor, + ): + unclipped_loss = -advantages * ratio + clipped_loss = -advantages * torch.clamp( + ratio, + 1.0 - clip_range, + 1.0 + clip_range, + ) + return torch.mean(torch.maximum(unclipped_loss, clipped_loss)) + + def _setup_optimizer(self, trainable_layers_parameters): + if self.config.train_use_8bit_adam: + import bitsandbytes + + optimizer_cls = bitsandbytes.optim.AdamW8bit + else: + optimizer_cls = torch.optim.AdamW + + return optimizer_cls( + trainable_layers_parameters, + lr=self.config.train_learning_rate, + betas=(self.config.train_adam_beta1, self.config.train_adam_beta2), + weight_decay=self.config.train_adam_weight_decay, + eps=self.config.train_adam_epsilon, + ) + + def _save_model_hook(self, models, weights, output_dir): + self.sd_pipeline.save_checkpoint(models, weights, output_dir) + weights.pop() # ensures that accelerate doesn't try to handle saving of the model + + def _load_model_hook(self, models, input_dir): + self.sd_pipeline.load_checkpoint(models, input_dir) + models.pop() # ensures that accelerate doesn't try to handle loading of the model + + def _generate_samples(self, iterations, batch_size): + """ + Generate samples from the model + + Args: + iterations (int): Number of iterations to generate samples for + batch_size (int): Batch size to use for sampling + + Returns: + samples (List[Dict[str, torch.Tensor]]), prompt_image_pairs (List[List[Any]]) + """ + samples = [] + prompt_image_pairs = [] + self.sd_pipeline.unet.eval() + + sample_neg_prompt_embeds = self.neg_prompt_embed.repeat(batch_size, 1, 1) + + for _ in range(iterations): + prompts, prompt_metadata = zip(*[self.prompt_fn() for _ in range(batch_size)]) + + prompt_ids = self.sd_pipeline.tokenizer( + prompts, + return_tensors="pt", + padding="max_length", + truncation=True, + max_length=self.sd_pipeline.tokenizer.model_max_length, + ).input_ids.to(self.accelerator.device) + prompt_embeds = self.sd_pipeline.text_encoder(prompt_ids)[0] + + with self.autocast(): + sd_output = self.sd_pipeline( + prompt_embeds=prompt_embeds, + negative_prompt_embeds=sample_neg_prompt_embeds, + num_inference_steps=self.config.sample_num_steps, + guidance_scale=self.config.sample_guidance_scale, + eta=self.config.sample_eta, + output_type="pt", + ) + + images = sd_output.images + latents = sd_output.latents + log_probs = sd_output.log_probs + + latents = torch.stack(latents, dim=1) # (batch_size, num_steps + 1, ...) + log_probs = torch.stack(log_probs, dim=1) # (batch_size, num_steps, 1) + timesteps = self.sd_pipeline.scheduler.timesteps.repeat(batch_size, 1) # (batch_size, num_steps) + + samples.append( + { + "prompt_ids": prompt_ids, + "prompt_embeds": prompt_embeds, + "timesteps": timesteps, + "latents": latents[:, :-1], # each entry is the latent before timestep t + "next_latents": latents[:, 1:], # each entry is the latent after timestep t + "log_probs": log_probs, + "negative_prompt_embeds": sample_neg_prompt_embeds, + } + ) + prompt_image_pairs.append([images, prompts, prompt_metadata]) + + return samples, prompt_image_pairs + + def _train_batched_samples(self, inner_epoch, epoch, global_step, batched_samples): + """ + Train on a batch of samples. Main training segment + + Args: + inner_epoch (int): The current inner epoch + epoch (int): The current epoch + global_step (int): The current global step + batched_samples (List[Dict[str, torch.Tensor]]): The batched samples to train on + + Side Effects: + - Model weights are updated + - Logs the statistics to the accelerator trackers. + + Returns: + global_step (int): The updated global step + """ + info = defaultdict(list) + for i, sample in enumerate(batched_samples): + if self.config.train_cfg: + # concat negative prompts to sample prompts to avoid two forward passes + embeds = torch.cat([sample["negative_prompt_embeds"], sample["prompt_embeds"]]) + else: + embeds = sample["prompt_embeds"] + + for j in range(self.num_train_timesteps): + with self.accelerator.accumulate(self.sd_pipeline.unet): + loss, approx_kl, clipfrac = self.calculate_loss( + sample["latents"][:, j], + sample["timesteps"][:, j], + sample["next_latents"][:, j], + sample["log_probs"][:, j], + sample["advantages"], + embeds, + ) + info["approx_kl"].append(approx_kl) + info["clipfrac"].append(clipfrac) + info["loss"].append(loss) + + self.accelerator.backward(loss) + if self.accelerator.sync_gradients: + self.accelerator.clip_grad_norm_( + self.trainable_layers.parameters() if not isinstance(self.trainable_layers, list) else self.trainable_layers, + self.config.train_max_grad_norm, + ) + self.optimizer.step() + self.optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if self.accelerator.sync_gradients: + # log training-related stuff + info = {k: torch.mean(torch.stack(v)) for k, v in info.items()} + info = self.accelerator.reduce(info, reduction="mean") + info.update({"epoch": epoch, "inner_epoch": inner_epoch}) + self.accelerator.log(info, step=global_step) + global_step += 1 + info = defaultdict(list) + return global_step + + def _config_check(self) -> Tuple[bool, str]: + samples_per_epoch = self.config.sample_batch_size * self.accelerator.num_processes * self.config.sample_num_batches_per_epoch + total_train_batch_size = self.config.train_batch_size * self.accelerator.num_processes * self.config.train_gradient_accumulation_steps + + if not self.config.sample_batch_size >= self.config.train_batch_size: + return ( + False, + f"Sample batch size ({self.config.sample_batch_size}) must be greater than or equal to the train batch size ({self.config.train_batch_size})", + ) + if not self.config.sample_batch_size % self.config.train_batch_size == 0: + return ( + False, + f"Sample batch size ({self.config.sample_batch_size}) must be divisible by the train batch size ({self.config.train_batch_size})", + ) + if not samples_per_epoch % total_train_batch_size == 0: + return ( + False, + f"Number of samples per epoch ({samples_per_epoch}) must be divisible by the total train batch size ({total_train_batch_size})", + ) + return True, "" + + def train(self, epochs: Optional[int] = None): + """ + Train the model for a given number of epochs + """ + global_step = 0 + if epochs is None: + epochs = self.config.num_epochs + for epoch in range(self.first_epoch, epochs): + global_step = self.step(epoch, global_step) + + def create_model_card(self, path: str, model_name: Optional[str] = "TRL DDPO Model") -> None: + """Creates and saves a model card for a TRL model. + + Args: + path (`str`): The path to save the model card to. + model_name (`str`, *optional*): The name of the model, defaults to `TRL DDPO Model`. + """ + try: + user = whoami()["name"] + # handle the offline case + except: # noqa + warnings.warn("Cannot retrieve user information assuming you are running in offline mode.") + return + + if not os.path.exists(path): + os.makedirs(path) + + model_card_content = MODEL_CARD_TEMPLATE.format(model_name=model_name, model_id=f"{user}/{path}") + with open(os.path.join(path, "README.md"), "w", encoding="utf-8") as f: + f.write(model_card_content) + + def _save_pretrained(self, save_directory): + self.sd_pipeline.save_pretrained(save_directory) + self.create_model_card(save_directory) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/dpo_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/dpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..ae2df89809a497bf4933686c663c55be88a75057 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/dpo_trainer.py @@ -0,0 +1,1186 @@ +# DPO Authors: Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, and Chelsea Finn 2023 +# Copyright 2023 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import inspect +import random +import warnings +from collections import defaultdict +from contextlib import contextmanager, nullcontext +from copy import deepcopy +from functools import wraps +from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from accelerate import PartialState +from accelerate.utils import is_deepspeed_available, tqdm +from datasets import Dataset +from torch.utils.data import DataLoader +from transformers import ( + AutoModelForCausalLM, + DataCollator, + PreTrainedModel, + PreTrainedTokenizerBase, + Trainer, + TrainingArguments, +) +from transformers.trainer_callback import TrainerCallback +from transformers.trainer_utils import EvalLoopOutput + +from ..import_utils import is_peft_available, is_wandb_available +from ..models import PreTrainedModelWrapper, create_reference_model +from .utils import ( + DPODataCollatorWithPadding, + disable_dropout_in_model, + pad_to_length, + peft_module_casting_to_bf16, + trl_sanitze_kwargs_for_tagging, +) + + +if is_peft_available(): + from peft import PeftModel, get_peft_model, prepare_model_for_kbit_training + + +if is_wandb_available(): + import wandb + +if is_deepspeed_available(): + import deepspeed + +from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled + + +class DPOTrainer(Trainer): + r""" + Initialize DPOTrainer. + + Args: + model (`transformers.PreTrainedModel`): + The model to train, preferably an `AutoModelForSequenceClassification`. + ref_model (`PreTrainedModelWrapper`): + Hugging Face transformer model with a casual language modelling head. Used for implicit reward computation and loss. If no + reference model is provided, the trainer will create a reference model with the same architecture as the model to be optimized. + beta (`float`, defaults to 0.1): + The beta factor in DPO loss. Higher beta means less divergence from the initial policy. For the IPO loss, beta is the regularization parameter denoted by tau in the paper. + label_smoothing (`float`, defaults to 0): + The robust DPO label smoothing parameter from the [cDPO](https://ericmitchell.ai/cdpo.pdf) report that should be between 0 and 0.5. + loss_type (`str`, defaults to `"sigmoid"`): + The type of DPO loss to use. Either `"sigmoid"` the default DPO loss,`"hinge"` loss from [SLiC](https://arxiv.org/abs/2305.10425) paper, `"ipo"` from [IPO](https://arxiv.org/abs/2310.12036) paper, or `"kto"` from the HALOs [report](https://github.com/ContextualAI/HALOs/blob/main/assets/report.pdf). + args (`transformers.TrainingArguments`): + The arguments to use for training. + data_collator (`transformers.DataCollator`): + The data collator to use for training. If None is specified, the default data collator (`DPODataCollatorWithPadding`) will be used + which will pad the sequences to the maximum length of the sequences in the batch, given a dataset of paired sequences. + label_pad_token_id (`int`, defaults to `-100`): + The label pad token id. This argument is required if you want to use the default data collator. + padding_value (`int`, defaults to `0`): + The padding value if it is different to the tokenizer's pad_token_id. + truncation_mode (`str`, defaults to `keep_end`): + The truncation mode to use, either `keep_end` or `keep_start`. This argument is required if you want to use the default data collator. + train_dataset (`datasets.Dataset`): + The dataset to use for training. + eval_dataset (`datasets.Dataset`): + The dataset to use for evaluation. + tokenizer (`transformers.PreTrainedTokenizerBase`): + The tokenizer to use for training. This argument is required if you want to use the default data collator. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be used. + callbacks (`List[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + max_length (`int`, defaults to `None`): + The maximum length of the sequences in the batch. This argument is required if you want to use the default data collator. + max_prompt_length (`int`, defaults to `None`): + The maximum length of the prompt. This argument is required if you want to use the default data collator. + max_target_length (`int`, defaults to `None`): + The maximum length of the target. This argument is required if you want to use the default data collator and your model is an encoder-decoder. + peft_config (`Dict`, defaults to `None`): + The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in a PEFT model. + is_encoder_decoder (`Optional[bool]`, `optional`, defaults to `None`): + If no model is provided, we need to know if the model_init returns an encoder-decoder. + disable_dropout (`bool`, defaults to `True`): + Whether or not to disable dropouts in `model` and `ref_model`. + generate_during_eval (`bool`, defaults to `False`): + Whether to sample and log generations during evaluation step. + compute_metrics (`Callable[[EvalPrediction], Dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return + a dictionary string to metric values. + precompute_ref_log_probs (`bool`, defaults to `False`): + Flag to precompute reference model log probabilities and evaluation datasets. This is useful if you want to train + without the reference model and reduce the total GPU memory needed. + dataset_num_proc (`Optional[int]`, *optional*): + The number of workers to use to tokenize the data. Defaults to None. + model_init_kwargs (`Optional[Dict]`, *optional*): + Dict of Optional kwargs to pass when instantiating the model from a string + ref_model_init_kwargs (`Optional[Dict]`, *optional*): + Dict of Optional kwargs to pass when instantiating the ref model from a string + model_adapter_name (`str`, defaults to `None`): + Name of the train target PEFT adapter, when using LoRA with multiple adapters. + ref_adapter_name (`str`, defaults to `None`): + Name of the reference PEFT adapter, when using LoRA with multiple adapters. + reference_free (`bool`): + If True, we ignore the _provided_ reference model and implicitly use a reference model that assigns equal probability to all responses. + """ + + _tag_names = ["trl", "dpo"] + + def __init__( + self, + model: Optional[Union[PreTrainedModel, nn.Module, str]] = None, + ref_model: Optional[Union[PreTrainedModel, nn.Module, str]] = None, + dpo_alpha: float = 1.0, + beta: float = 0.1, + gamma: float = 0.1, + label_smoothing: float = 0, + loss_type: Literal["sigmoid", "hinge", "ipo", "kto_pair"] = "sigmoid", + args: Optional[TrainingArguments] = None, + data_collator: Optional[DataCollator] = None, + label_pad_token_id: int = -100, + padding_value: Optional[int] = None, + truncation_mode: str = "keep_end", + train_dataset: Optional[Dataset] = None, + eval_dataset: Optional[Union[Dataset, Dict[str, Dataset]]] = None, + tokenizer: Optional[PreTrainedTokenizerBase] = None, + model_init: Optional[Callable[[], PreTrainedModel]] = None, + callbacks: Optional[List[TrainerCallback]] = None, + optimizers: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None, + max_length: Optional[int] = None, + max_prompt_length: Optional[int] = None, + max_target_length: Optional[int] = None, + peft_config: Optional[Dict] = None, + is_encoder_decoder: Optional[bool] = None, + disable_dropout: bool = True, + generate_during_eval: bool = False, + compute_metrics: Optional[Callable[[EvalLoopOutput], Dict]] = None, + precompute_ref_log_probs: bool = False, + dataset_num_proc: Optional[int] = None, + model_init_kwargs: Optional[Dict] = None, + ref_model_init_kwargs: Optional[Dict] = None, + model_adapter_name: Optional[str] = None, + ref_adapter_name: Optional[str] = None, + reference_free: bool = False, + ): + # import pdb;pdb.set_trace() + if model_init_kwargs is None: + model_init_kwargs = {} + elif not isinstance(model, str): + raise ValueError("You passed model_kwargs to the DPOTrainer. But your model is already instantiated.") + + if ref_model_init_kwargs is None: + ref_model_init_kwargs = {} + elif not isinstance(ref_model, str): + raise ValueError("You passed ref_model_kwargs to the DPOTrainer. But your ref_model is already instantiated.") + + if isinstance(model, str): + warnings.warn("You passed a model_id to the DPOTrainer. This will automatically create an " "`AutoModelForCausalLM` or a `PeftModel` (if you passed a `peft_config`) for you.") + model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs) + + if isinstance(ref_model, str): + warnings.warn("You passed a ref model_id to the DPOTrainer. This will automatically create an " "`AutoModelForCausalLM`") + ref_model = AutoModelForCausalLM.from_pretrained(ref_model, **ref_model_init_kwargs) + + # Initialize this variable to False. This helps tracking the case when `peft_module_casting_to_bf16` + # has been called in order to properly call autocast if needed. + self._peft_has_been_casted_to_bf16 = False + + if generate_during_eval and not is_wandb_available(): + raise ValueError("`generate_during_eval=True` requires Weights and Biases to be installed." " Please install `wandb` to resolve.") + + if model is not None: + self.is_encoder_decoder = model.config.is_encoder_decoder + elif is_encoder_decoder is None: + raise ValueError("When no model is provided, you need to pass the parameter is_encoder_decoder.") + else: + self.is_encoder_decoder = is_encoder_decoder + + self.is_peft_model = is_peft_available() and isinstance(model, PeftModel) + self.model_adapter_name = model_adapter_name + self.ref_adapter_name = ref_adapter_name + self.reference_free = reference_free + + if ref_model: + self.ref_model = ref_model + elif self.is_peft_model or precompute_ref_log_probs: + # The `model` with adapters turned off will be used as the reference model + self.ref_model = None + else: + if is_deepspeed_zero3_enabled(): + self.ref_model = AutoModelForCausalLM.from_pretrained(model) + else: + self.ref_model = create_reference_model(model) + + if tokenizer is None: + raise ValueError("tokenizer must be specified to tokenize a DPO dataset.") + if max_length is None: + warnings.warn( + "`max_length` is not set in the DPOTrainer's init" " it will default to `512` by default, but you should do it yourself in the future.", + UserWarning, + ) + max_length = 512 + if max_prompt_length is None: + warnings.warn( + "`max_prompt_length` is not set in the DPOTrainer's init" " it will default to `128` by default, but you should do it yourself in the future.", + UserWarning, + ) + max_prompt_length = 128 + + if max_target_length is None and self.is_encoder_decoder: + warnings.warn( + "When using an encoder decoder architecture, you should set `max_target_length` in the DPOTrainer's init" " it will default to `128` by default, but you should do it yourself in the future.", + UserWarning, + ) + max_target_length = 128 + + if data_collator is None: + data_collator = DPODataCollatorWithPadding( + pad_token_id=tokenizer.pad_token_id, + label_pad_token_id=label_pad_token_id, + is_encoder_decoder=self.is_encoder_decoder, + ) + + if args.remove_unused_columns: + args.remove_unused_columns = False + # warn users + warnings.warn( + "When using DPODataCollatorWithPadding, you should set `remove_unused_columns=False` in your TrainingArguments" " we have set it for you, but you should do it yourself in the future.", + UserWarning, + ) + + self.use_dpo_data_collator = True + else: + self.use_dpo_data_collator = False + + if disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + self.max_length = max_length + self.generate_during_eval = generate_during_eval + self.label_pad_token_id = label_pad_token_id + self.padding_value = padding_value if padding_value is not None else tokenizer.pad_token_id + self.max_prompt_length = max_prompt_length + self.truncation_mode = truncation_mode + self.max_target_length = max_target_length + self.tokenizer = tokenizer + self.precompute_ref_log_probs = precompute_ref_log_probs + + # Since ref_logs are precomputed on the first call to get_train/eval_dataloader + # keep track of first called to avoid computation of future calls + self._precomputed_train_ref_log_probs = False + self._precomputed_eval_ref_log_probs = False + + if loss_type in ["hinge", "ipo", "kto_pair"] and label_smoothing > 0: + warnings.warn("You are using a loss type that does not support label smoothing. Ignoring label_smoothing parameter.") + + self.dpo_alpha = dpo_alpha + self.beta = beta + self.gamma = gamma + self.label_smoothing = label_smoothing + self.loss_type = loss_type + + self._stored_metrics = defaultdict(lambda: defaultdict(list)) + + self.dataset_num_proc = dataset_num_proc + + # Compute that only on the main process for faster data processing. + # see: https://github.com/huggingface/trl/pull/1255 + # with PartialState().local_main_process_first(): + # # tokenize the dataset + # train_dataset = train_dataset.map(self.tokenize_row, num_proc=self.dataset_num_proc) + # if eval_dataset is not None: + # eval_dataset = eval_dataset.map(self.tokenize_row, num_proc=self.dataset_num_proc) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + tokenizer=tokenizer, + model_init=model_init, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + if not hasattr(self, "accelerator"): + raise AttributeError("Your `Trainer` does not have an `accelerator` object. Consider upgrading `transformers`.") + + # Deepspeed Zero-3 does not support precompute_ref_log_probs + if self.is_deepspeed_enabled: + if self.accelerator.state.deepspeed_plugin.zero_stage == 3 and self.precompute_ref_log_probs: + raise ValueError("You cannot use `precompute_ref_log_probs=True` with Deepspeed ZeRO-3. Please set `precompute_ref_log_probs=False`.") + + if self.ref_model is None: + if not (self.is_peft_model or self.precompute_ref_log_probs): + raise ValueError("No reference model and model is not a Peft model. Try setting `precompute_ref_log_probs=True`") + else: + if self.is_deepspeed_enabled: + self.ref_model = self._prepare_deepspeed(self.ref_model) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + def _prepare_deepspeed(self, model: PreTrainedModelWrapper): + # Adapted from accelerate: https://github.com/huggingface/accelerate/blob/739b135f8367becb67ffaada12fe76e3aa60fefd/src/accelerate/accelerator.py#L1473 + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + config_kwargs = deepcopy(deepspeed_plugin.deepspeed_config) + + if model is not None: + if hasattr(model, "config"): + hidden_size = max(model.config.hidden_sizes) if getattr(model.config, "hidden_sizes", None) else getattr(model.config, "hidden_size", None) + if hidden_size is not None and config_kwargs["zero_optimization"]["stage"] == 3: + # Note that `stage3_prefetch_bucket_size` can produce DeepSpeed messages like: `Invalidate trace cache @ step 0: expected module 1, but got module 0` + # This is expected and is not an error, see: https://github.com/microsoft/DeepSpeed/discussions/4081 + config_kwargs.update( + { + "zero_optimization.reduce_bucket_size": hidden_size * hidden_size, + "zero_optimization.stage3_param_persistence_threshold": 10 * hidden_size, + "zero_optimization.stage3_prefetch_bucket_size": 0.9 * hidden_size * hidden_size, + } + ) + + # If ZeRO-3 is used, we shard both the active and reference model. + # Otherwise, we assume the reference model fits in memory and is initialized on each device with ZeRO disabled (stage 0) + if config_kwargs["zero_optimization"]["stage"] != 3: + config_kwargs["zero_optimization"]["stage"] = 0 + model, *_ = deepspeed.initialize(model=model, config=config_kwargs) + model.eval() + return model + + def get_train_dataloader(self) -> DataLoader: + """ + Returns the training [`~torch.utils.data.DataLoader`]. + + Subclass of transformers.src.transformers.trainer.get_train_dataloader to precompute `ref_log_probs`. + """ + + if self.precompute_ref_log_probs and not self._precomputed_train_ref_log_probs: + dataloader_params = { + "batch_size": self.args.per_device_train_batch_size, + "collate_fn": self.data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "shuffle": False, + } + + # prepare dataloader + data_loader = self.accelerator.prepare(DataLoader(self.train_dataset, **dataloader_params)) + + reference_chosen_logps = [] + reference_rejected_logps = [] + for padded_batch in tqdm(iterable=data_loader, desc="Train dataset reference log probs"): + reference_chosen_logp, reference_rejected_logp = self.compute_reference_log_probs(padded_batch) + reference_chosen_logp, reference_rejected_logp = self.accelerator.gather_for_metrics((reference_chosen_logp, reference_rejected_logp)) + reference_chosen_logps.append(reference_chosen_logp.cpu()) + reference_rejected_logps.append(reference_rejected_logp.cpu()) + + all_reference_chosen_logps = torch.cat(reference_chosen_logps).float().numpy() + all_reference_rejected_logps = torch.cat(reference_rejected_logps).float().numpy() + + self.train_dataset = self.train_dataset.add_column(name="reference_chosen_logps", column=all_reference_chosen_logps) + self.train_dataset = self.train_dataset.add_column(name="reference_rejected_logps", column=all_reference_rejected_logps) + + self._precomputed_train_ref_log_probs = True + + return super().get_train_dataloader() + + def get_eval_dataloader(self, eval_dataset: Optional[Dataset] = None) -> DataLoader: + """ + Returns the evaluation [`~torch.utils.data.DataLoader`]. + + Subclass of transformers.src.transformers.trainer.get_eval_dataloader to precompute `ref_log_probs`. + + Args: + eval_dataset (`torch.utils.data.Dataset`, *optional*): + If provided, will override `self.eval_dataset`. If it is a [`~datasets.Dataset`], columns not accepted + by the `model.forward()` method are automatically removed. It must implement `__len__`. + """ + if eval_dataset is None and self.eval_dataset is None: + raise ValueError("Trainer: evaluation requires an eval_dataset.") + eval_dataset = eval_dataset if eval_dataset is not None else self.eval_dataset + + if self.precompute_ref_log_probs and not self._precomputed_eval_ref_log_probs: + dataloader_params = { + "batch_size": self.args.per_device_eval_batch_size, + "collate_fn": self.data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "shuffle": False, + } + + # prepare dataloader + data_loader = self.accelerator.prepare(DataLoader(eval_dataset, **dataloader_params)) + + reference_chosen_logps = [] + reference_rejected_logps = [] + for padded_batch in tqdm(iterable=data_loader, desc="Eval dataset reference log probs"): + reference_chosen_logp, reference_rejected_logp = self.compute_reference_log_probs(padded_batch) + reference_chosen_logp, reference_rejected_logp = self.accelerator.gather_for_metrics((reference_chosen_logp, reference_rejected_logp)) + reference_chosen_logps.append(reference_chosen_logp.cpu()) + reference_rejected_logps.append(reference_rejected_logp.cpu()) + + all_reference_chosen_logps = torch.cat(reference_chosen_logps).float().numpy() + all_reference_rejected_logps = torch.cat(reference_rejected_logps).float().numpy() + + eval_dataset = eval_dataset.add_column(name="reference_chosen_logps", column=all_reference_chosen_logps) + eval_dataset = eval_dataset.add_column(name="reference_rejected_logps", column=all_reference_rejected_logps) + + # Save calculated reference_chosen_logps and reference_rejected_logps to the eval_dataset for subsequent runs + if self.eval_dataset is not None: + self.eval_dataset = eval_dataset + self._precomputed_eval_ref_log_probs = True + + return super().get_eval_dataloader(eval_dataset=eval_dataset) + + def build_tokenized_answer(self, prompt, answer): + """ + Llama tokenizer does satisfy `enc(a + b) = enc(a) + enc(b)`. + It does ensure `enc(a + b) = enc(a) + enc(a + b)[len(enc(a)):]`. + Reference: + https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + """ + + full_tokenized = self.tokenizer(prompt + answer, add_special_tokens=False) + prompt_input_ids = self.tokenizer(prompt, add_special_tokens=False)["input_ids"] + + answer_input_ids = full_tokenized["input_ids"][len(prompt_input_ids) :] + answer_attention_mask = full_tokenized["attention_mask"][len(prompt_input_ids) :] + + # Concat tokens to form `enc(a) + enc(a + b)[len(enc(a)):]` + full_concat_input_ids = np.concatenate([prompt_input_ids, answer_input_ids]) + + # Prepare input tokens for token by token comparison + full_input_ids = np.array(full_tokenized["input_ids"]) + + if len(full_input_ids) != len(full_concat_input_ids): + raise ValueError("Prompt input ids and answer input ids should have the same length.") + + # On some tokenizers, like Llama-2 tokenizer, there are occasions where tokens + # can be merged together when tokenizing prompt+answer. This could result + # on the last token from the prompt being different when tokenized on its own + # vs when done as prompt+answer. + response_token_ids_start_idx = len(prompt_input_ids) + + # If tokenized prompt is different than both prompt+answer, then it means the + # last token has changed due to merging. + if prompt_input_ids != full_tokenized["input_ids"][:response_token_ids_start_idx]: + response_token_ids_start_idx -= 1 + + prompt_input_ids = full_tokenized["input_ids"][:response_token_ids_start_idx] + prompt_attention_mask = full_tokenized["attention_mask"][:response_token_ids_start_idx] + + if len(prompt_input_ids) != len(prompt_attention_mask): + raise ValueError("Prompt input ids and attention mask should have the same length.") + + answer_input_ids = full_tokenized["input_ids"][response_token_ids_start_idx:] + answer_attention_mask = full_tokenized["attention_mask"][response_token_ids_start_idx:] + + return dict( + prompt_input_ids=prompt_input_ids, + prompt_attention_mask=prompt_attention_mask, + input_ids=answer_input_ids, + attention_mask=answer_attention_mask, + ) + + def tokenize_row(self, feature, model: Optional[Union[PreTrainedModel, nn.Module]] = None) -> Dict: + """Tokenize a single row from a DPO specific dataset. + + At this stage, we don't convert to PyTorch tensors yet; we just handle the truncation + in case the prompt + chosen or prompt + rejected responses is/are too long. First + we truncate the prompt; if we're still too long, we truncate the chosen/rejected. + + We also create the labels for the chosen/rejected responses, which are of length equal to + the sum of the length of the prompt and the chosen/rejected response, with + label_pad_token_id for the prompt tokens. + """ + batch = {} + prompt = feature["prompt"] + chosen = feature["chosen"] + rejected = feature["rejected"] + + if not self.is_encoder_decoder: + # Check issues below for more details + # 1. https://github.com/huggingface/trl/issues/907 + # 2. https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + # 3. https://github.com/LianjiaTech/BELLE/issues/337 + + if not isinstance(prompt, str): + raise ValueError(f"prompt should be an str but got {type(prompt)}") + prompt_tokens = self.tokenizer(prompt, add_special_tokens=False) + prompt_tokens = {f"prompt_{k}": v for k, v in prompt_tokens.items()} + + if not isinstance(chosen, str): + raise ValueError(f"chosen should be an str but got {type(chosen)}") + chosen_tokens = self.build_tokenized_answer(prompt, chosen) + + if not isinstance(rejected, str): + raise ValueError(f"rejected should be an str but got {type(rejected)}") + rejected_tokens = self.build_tokenized_answer(prompt, rejected) + + # Last prompt token might get merged by tokenizer and + # it should not be included for generation if that happens + prompt_len_input_ids = len(prompt_tokens["prompt_input_ids"]) + + chosen_prompt_len_input_ids = len(chosen_tokens["prompt_input_ids"]) + rejected_prompt_len_input_ids = len(rejected_tokens["prompt_input_ids"]) + prompt_len_input_ids = min(chosen_prompt_len_input_ids, rejected_prompt_len_input_ids) + + for k, v in prompt_tokens.items(): + prompt_tokens[k] = v[:prompt_len_input_ids] + + # Make sure prompts only have one different token at most an + # and length only differs by 1 at most + num_diff_tokens = sum([a != b for a, b in zip(chosen_tokens["prompt_input_ids"], rejected_tokens["prompt_input_ids"])]) + num_diff_len = abs(chosen_prompt_len_input_ids - rejected_prompt_len_input_ids) + if num_diff_tokens > 1 or num_diff_len > 1: + raise ValueError("Chosen and rejected prompt_input_ids might only differ on the " "last token due to tokenizer merge ops.") + + # add BOS token to head of prompt + prompt_tokens["prompt_input_ids"] = [self.tokenizer.bos_token_id] + prompt_tokens["prompt_input_ids"] + chosen_tokens["prompt_input_ids"] = [self.tokenizer.bos_token_id] + chosen_tokens["prompt_input_ids"] + rejected_tokens["prompt_input_ids"] = [self.tokenizer.bos_token_id] + rejected_tokens["prompt_input_ids"] + + prompt_tokens["prompt_attention_mask"] = [1] + prompt_tokens["prompt_attention_mask"] + chosen_tokens["prompt_attention_mask"] = [1] + chosen_tokens["prompt_attention_mask"] + rejected_tokens["prompt_attention_mask"] = [1] + rejected_tokens["prompt_attention_mask"] + + # add EOS token to end of answer + chosen_tokens["input_ids"].append(self.tokenizer.eos_token_id) + chosen_tokens["attention_mask"].append(1) + + rejected_tokens["input_ids"].append(self.tokenizer.eos_token_id) + rejected_tokens["attention_mask"].append(1) + + longer_response_length = max(len(chosen_tokens["input_ids"]), len(rejected_tokens["input_ids"])) + + # if combined sequence is too long, truncate the prompt + for answer_tokens in [chosen_tokens, rejected_tokens, prompt_tokens]: + if len(answer_tokens["prompt_input_ids"]) + longer_response_length > self.max_length: + if self.truncation_mode == "keep_start": + for k in ["prompt_input_ids", "prompt_attention_mask"]: + answer_tokens[k] = answer_tokens[k][: self.max_prompt_length] + elif self.truncation_mode == "keep_end": + for k in ["prompt_input_ids", "prompt_attention_mask"]: + answer_tokens[k] = answer_tokens[k][-self.max_prompt_length :] + else: + raise ValueError(f"Unknown truncation mode: {self.truncation_mode}") + + # if that's still too long, truncate the response + for answer_tokens in [chosen_tokens, rejected_tokens]: + if len(answer_tokens["prompt_input_ids"]) + longer_response_length > self.max_length: + for k in ["input_ids", "attention_mask"]: + answer_tokens[k] = answer_tokens[k][: self.max_length - self.max_prompt_length] + + # Create labels + chosen_sequence_tokens = {k: chosen_tokens[f"prompt_{k}"] + chosen_tokens[k] for k in ["input_ids", "attention_mask"]} + rejected_sequence_tokens = {k: rejected_tokens[f"prompt_{k}"] + rejected_tokens[k] for k in ["input_ids", "attention_mask"]} + chosen_sequence_tokens["labels"] = chosen_sequence_tokens["input_ids"][:] + chosen_sequence_tokens["labels"][: len(chosen_tokens["prompt_input_ids"])] = [self.label_pad_token_id] * len(chosen_tokens["prompt_input_ids"]) + rejected_sequence_tokens["labels"] = rejected_sequence_tokens["input_ids"][:] + rejected_sequence_tokens["labels"][: len(rejected_tokens["prompt_input_ids"])] = [self.label_pad_token_id] * len(rejected_tokens["prompt_input_ids"]) + + for k, toks in { + "chosen_": chosen_sequence_tokens, + "rejected_": rejected_sequence_tokens, + "": prompt_tokens, + }.items(): + for type_key, tokens in toks.items(): + if type_key == "token_type_ids": + continue + batch[f"{k}{type_key}"] = tokens + + else: + chosen_tokens = self.tokenizer(chosen, truncation=True, max_length=self.max_target_length, add_special_tokens=True) + rejected_tokens = self.tokenizer(rejected, truncation=True, max_length=self.max_target_length, add_special_tokens=True) + prompt_tokens = self.tokenizer(prompt, truncation=True, max_length=self.max_prompt_length, add_special_tokens=True) + + batch["chosen_labels"] = chosen_tokens["input_ids"] + batch["rejected_labels"] = rejected_tokens["input_ids"] + batch["prompt_input_ids"] = prompt_tokens["input_ids"] + batch["prompt_attention_mask"] = prompt_tokens["attention_mask"] + + if model is not None and hasattr(model, "prepare_decoder_input_ids_from_labels"): + batch["rejected_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels(labels=batch["rejected_labels"]) + batch["chosen_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels(labels=batch["chosen_labels"]) + + return batch + + @contextmanager + def null_ref_context(self): + """Context manager for handling null reference model (that is, peft adapter manipulation).""" + with self.accelerator.unwrap_model(self.model).disable_adapter() if self.is_peft_model and not self.ref_adapter_name else nullcontext(): + if self.ref_adapter_name: + self.model.set_adapter(self.ref_adapter_name) + yield + if self.ref_adapter_name: + self.model.set_adapter(self.model_adapter_name or "default") + + def compute_reference_log_probs(self, padded_batch: Dict) -> Dict: + """Computes log probabilities of the reference model for a single padded batch of a DPO specific dataset.""" + compte_ref_context_manager = torch.cuda.amp.autocast if self._peft_has_been_casted_to_bf16 else nullcontext + + # compute reference logps + with torch.no_grad(), compte_ref_context_manager(): + if self.ref_model is None: + with self.null_ref_context(): + ( + reference_chosen_logps, + reference_rejected_logps, + _, + _, + ) = self.concatenated_forward(self.model, padded_batch) + else: + ( + reference_chosen_logps, + reference_rejected_logps, + _, + _, + ) = self.concatenated_forward(self.ref_model, padded_batch) + + return reference_chosen_logps, reference_rejected_logps + + @staticmethod + def concatenated_inputs( + batch: Dict[str, Union[List, torch.LongTensor]], + is_encoder_decoder: bool = False, + label_pad_token_id: int = -100, + padding_value: int = 0, + device: Optional[torch.device] = None, + ) -> Dict[str, torch.LongTensor]: + """Concatenate the chosen and rejected inputs into a single tensor. + + Args: + batch: A batch of data. Must contain the keys 'chosen_input_ids' and 'rejected_input_ids', which are tensors of shape (batch_size, sequence_length). + is_encoder_decoder: Whether the model is an encoder-decoder model. + label_pad_token_id: The label pad token id. + padding_value: The padding value to use for the concatenated inputs_ids. + device: The device for the concatenated inputs. + + Returns: + A dictionary containing the concatenated inputs under the key 'concatenated_input_ids'. + """ + concatenated_batch = {} + + if is_encoder_decoder: + max_length = max(batch["chosen_labels"].shape[1], batch["rejected_labels"].shape[1]) + else: + max_length = max(batch["chosen_input_ids"].shape[1], batch["rejected_input_ids"].shape[1]) + + for k in batch: + # import pdb; pdb.set_trace() + if k.startswith("chosen") and isinstance(batch[k], torch.Tensor): + if "labels" in k or is_encoder_decoder: + pad_value = label_pad_token_id + elif k.endswith("_input_ids"): + pad_value = padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + concatenated_key = k.replace("chosen", "concatenated") + concatenated_batch[concatenated_key] = pad_to_length(batch[k], max_length, pad_value=pad_value) + for k in batch: + if k.startswith("rejected") and isinstance(batch[k], torch.Tensor): + if "labels" in k or is_encoder_decoder: + pad_value = label_pad_token_id + elif k.endswith("_input_ids"): + pad_value = padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + concatenated_key = k.replace("rejected", "concatenated") + concatenated_batch[concatenated_key] = torch.cat( + ( + concatenated_batch[concatenated_key], + pad_to_length(batch[k], max_length, pad_value=pad_value), + ), + dim=0, + ).to(device=device) + + if is_encoder_decoder: + concatenated_batch["concatenated_input_ids"] = batch["prompt_input_ids"].repeat(2, 1).to(device=device) + concatenated_batch["concatenated_attention_mask"] = batch["prompt_attention_mask"].repeat(2, 1).to(device=device) + # import pdb; pdb.set_trace() + # repeated_list = [ + # batch['images'][0] * 2, + # batch['images'][1] * 2 + # ] + concatenated_batch["concatenated_images"] = batch["images"] * 2 + concatenated_batch["image_sizes"] = batch["image_sizes"] * 2 + concatenated_batch["modalities"] = batch["modalities"] * 2 + return concatenated_batch + + def dpo_loss( + self, + policy_chosen_logps: torch.FloatTensor, + policy_rejected_logps: torch.FloatTensor, + reference_chosen_logps: torch.FloatTensor, + reference_rejected_logps: torch.FloatTensor, + ) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Compute the DPO loss for a batch of policy and reference model log probabilities. + + Args: + policy_chosen_logps: Log probabilities of the policy model for the chosen responses. Shape: (batch_size,) + policy_rejected_logps: Log probabilities of the policy model for the rejected responses. Shape: (batch_size,) + reference_chosen_logps: Log probabilities of the reference model for the chosen responses. Shape: (batch_size,) + reference_rejected_logps: Log probabilities of the reference model for the rejected responses. Shape: (batch_size,) + + Returns: + A tuple of three tensors: (losses, chosen_rewards, rejected_rewards). + The losses tensor contains the DPO loss for each example in the batch. + The chosen_rewards and rejected_rewards tensors contain the rewards for the chosen and rejected responses, respectively. + """ + pi_logratios = policy_chosen_logps - policy_rejected_logps + if self.reference_free: + ref_logratios = torch.tensor([0], dtype=pi_logratios.dtype, device=pi_logratios.device) + else: + ref_logratios = reference_chosen_logps - reference_rejected_logps + + pi_logratios = pi_logratios.to(self.accelerator.device) + ref_logratios = ref_logratios.to(self.accelerator.device) + logits = pi_logratios - ref_logratios + # print(f"pi log ratios: {pi_logratios}") + # print(f"ref log ratios: {ref_logratios}") + # print(f"logits: {logits}") + # The beta is a temperature parameter for the DPO loss, typically something in the range of 0.1 to 0.5. + # We ignore the reference model as beta -> 0. The label_smoothing parameter encodes our uncertainty about the labels and + # calculates a conservative DPO loss. + if self.loss_type == "sigmoid": + losses = -F.logsigmoid(self.beta * logits) * (1 - self.label_smoothing) - F.logsigmoid(-self.beta * logits) * self.label_smoothing + elif self.loss_type == "hinge": + losses = torch.relu(1 - self.beta * logits) + elif self.loss_type == "ipo": + # eqn (17) of the paper where beta is the regularization parameter for the IPO loss, denoted by tau in the paper. + losses = (logits - 1 / (2 * self.beta)) ** 2 + elif self.loss_type == "kto_pair": + # eqn (7) of the HALOs paper + chosen_KL = (policy_chosen_logps - reference_chosen_logps).mean().clamp(min=0) + rejected_KL = (policy_rejected_logps - reference_rejected_logps).mean().clamp(min=0) + + chosen_logratios = policy_chosen_logps - reference_chosen_logps + rejected_logratios = policy_rejected_logps - reference_rejected_logps + # As described in the KTO report, the KL term for chosen (rejected) is estimated using the rejected (chosen) half. + losses = torch.cat( + ( + 1 - F.sigmoid(self.beta * (chosen_logratios - rejected_KL)), + 1 - F.sigmoid(self.beta * (chosen_KL - rejected_logratios)), + ), + 0, + ) + else: + raise ValueError(f"Unknown loss type: {self.loss_type}. Should be one of ['sigmoid', 'hinge', 'ipo', 'kto_pair']") + + chosen_rewards = self.beta * (policy_chosen_logps.to(self.accelerator.device) - reference_chosen_logps.to(self.accelerator.device)).detach() + rejected_rewards = self.beta * (policy_rejected_logps.to(self.accelerator.device) - reference_rejected_logps.to(self.accelerator.device)).detach() + + return losses, chosen_rewards, rejected_rewards + + @staticmethod + def get_batch_logps( + logits: torch.FloatTensor, + labels: torch.LongTensor, + average_log_prob: bool = False, + label_pad_token_id: int = -100, + is_encoder_decoder: bool = False, + ) -> torch.FloatTensor: + """Compute the log probabilities of the given labels under the given logits. + + Args: + logits: Logits of the model (unnormalized). Shape: (batch_size, sequence_length, vocab_size) + labels: Labels for which to compute the log probabilities. Label tokens with a value of label_pad_token_id are ignored. Shape: (batch_size, sequence_length) + average_log_prob: If True, return the average log probability per (non-masked) token. Otherwise, return the sum of the log probabilities of the (non-masked) tokens. + label_pad_token_id: The label pad token id. + is_encoder_decoder: Whether the model is an encoder-decoder model. + + Returns: + A tensor of shape (batch_size,) containing the average/sum log probabilities of the given labels under the given logits. + """ + if logits.shape[:-1] != labels.shape: + raise ValueError("Logits (batch and sequence length dim) and labels must have the same shape.") + + if not is_encoder_decoder: + labels = labels[:, 1:].clone() + logits = logits[:, :-1, :] + loss_mask = labels != label_pad_token_id + + # dummy token; we'll ignore the losses on these tokens later + labels[labels == label_pad_token_id] = 0 + + per_token_logps = torch.gather(logits.log_softmax(-1), dim=2, index=labels.unsqueeze(2)).squeeze(2) + + if average_log_prob: + return (per_token_logps * loss_mask).sum(-1) / loss_mask.sum(-1) + else: + return (per_token_logps * loss_mask).sum(-1) + + def get_sft_loss(self, logits, labels): + # Shift so that tokens < n predict n + shift_logits = logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + # Flatten the tokens + loss_fct = nn.CrossEntropyLoss() + shift_logits = shift_logits.view(-1, shift_logits.size(-1)) + shift_labels = shift_labels.view(-1) + # Enable model/pipeline parallelism + shift_labels = shift_labels.to(shift_logits.device) + loss = loss_fct(shift_logits, shift_labels) + return loss + + def concatenated_forward(self, model: nn.Module, batch: Dict[str, Union[List, torch.LongTensor]]) -> Tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Run the given model on the given batch of inputs, concatenating the chosen and rejected inputs together. + + We do this to avoid doing two forward passes, because it's faster for FSDP. + """ + # import pdb; pdb.set_trace() + concatenated_batch = self.concatenated_inputs( + batch, + is_encoder_decoder=self.is_encoder_decoder, + label_pad_token_id=self.label_pad_token_id, + padding_value=self.padding_value, + device=self.accelerator.device, + ) + len_chosen = batch["chosen_labels"].shape[0] + + # import pdb; pdb.set_trace() + all_logits, new_labels = model( + concatenated_batch["concatenated_input_ids"], + attention_mask=concatenated_batch["concatenated_attention_mask"], + labels=concatenated_batch["concatenated_labels"], + images=concatenated_batch["concatenated_images"], + image_sizes=concatenated_batch["image_sizes"], + modalities=concatenated_batch["modalities"], + use_cache=False, + dpo_forward=True, + ) + all_logits = all_logits.to(torch.float32) + all_logps = self.get_batch_logps( + all_logits, + new_labels, + average_log_prob=self.loss_type == "ipo", + is_encoder_decoder=self.is_encoder_decoder, + label_pad_token_id=self.label_pad_token_id, + ) + + chosen_logps = all_logps[:len_chosen] + rejected_logps = all_logps[len_chosen:] + + # don't count image embeds logits + # loss_mask = new_labels != -100 + # logits = [all_logits[i][loss_mask[i]] for i in range(loss_mask.shape[0])] + # chosen_logits = logits[:len_chosen] + # rejected_logits = logits[len_chosen:] + # chosen_logits = [l.detach().cpu().mean() for l in chosen_logits] + # rejected_logits = [l.detach().cpu().mean() for l in rejected_logits] + # chosen_logits = sum(chosen_logits)/len_chosen + # rejected_logits = sum(rejected_logits)/len_chosen + + chosen_logits = all_logits[:len_chosen] + rejected_logits = all_logits[len_chosen:] + + chosen_labels = new_labels[:len_chosen] + rejected_labels = new_labels[len_chosen:] + + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, chosen_labels, rejected_labels) + + def get_batch_loss_metrics( + self, + model, + batch: Dict[str, Union[List, torch.LongTensor]], + train_eval: Literal["train", "eval"] = "train", + ): + """Compute the DPO loss and other metrics for the given batch of inputs for train or test. + CHANGE: 1. add sft loss + 2. all gather metrics + """ + metrics = {} + + ( + policy_chosen_logps, + policy_rejected_logps, + policy_chosen_logits, + policy_rejected_logits, + chosen_labels, + rejected_labels, + ) = self.concatenated_forward(model, batch) + + # if reference_chosen_logps and reference_rejected_logps in batch use them, otherwise use the reference model + if "reference_chosen_logps" in batch and "reference_rejected_logps" in batch: + reference_chosen_logps = batch["reference_chosen_logps"] + reference_rejected_logps = batch["reference_rejected_logps"] + else: + with torch.no_grad(): + if self.ref_model is None: + with self.null_ref_context(): + ( + reference_chosen_logps, + reference_rejected_logps, + ) = self.concatenated_forward( + self.model, batch + )[:2] + else: + ( + reference_chosen_logps, + reference_rejected_logps, + ) = self.concatenated_forward( + self.ref_model, batch + )[:2] + + unscaled_dpo_losses, chosen_rewards, rejected_rewards = self.dpo_loss( + policy_chosen_logps, + policy_rejected_logps, + reference_chosen_logps, + reference_rejected_logps, + ) + unscaled_dpo_losses = unscaled_dpo_losses.mean() + dpo_losses = unscaled_dpo_losses * self.dpo_alpha + unscaled_sft_loss = self.get_sft_loss(policy_chosen_logits, chosen_labels) + sft_loss = unscaled_sft_loss * self.gamma + + # print(sft_loss.shape, dpo_losses.shape) + losses = dpo_losses + sft_loss + # losses = sft_loss # sft only + # losses = dpo_losses # dpo only + reward_accuracies = (chosen_rewards > rejected_rewards).float() + + def all_gather_tensor(tensor): + if torch.distributed.is_available() and torch.distributed.is_initialized(): + tensor = tensor.detach() + gathered_tensor = [torch.zeros_like(tensor) for _ in range(torch.distributed.get_world_size())] + torch.distributed.all_gather(gathered_tensor, tensor) + tensor = torch.cat(gathered_tensor, dim=0) + # else: + # print('not distributed') + return tensor + + # gather chosen_rewards across devices + chosen_rewards = all_gather_tensor(chosen_rewards) + rejected_rewards = all_gather_tensor(rejected_rewards) + reward_accuracies = all_gather_tensor(reward_accuracies) + policy_chosen_logps = all_gather_tensor(policy_chosen_logps) + policy_rejected_logps = all_gather_tensor(policy_rejected_logps) + reference_chosen_logps = all_gather_tensor(reference_chosen_logps) + reference_rejected_logps = all_gather_tensor(reference_rejected_logps) + + prefix = "eval_" if train_eval == "eval" else "" + metrics[f"{prefix}losses/dpo"] = unscaled_dpo_losses.cpu() + metrics[f"{prefix}losses/sft"] = unscaled_sft_loss.cpu() + metrics[f"{prefix}losses/total"] = losses.cpu() + metrics[f"{prefix}rewards/chosen"] = chosen_rewards.mean().cpu() + metrics[f"{prefix}rewards/rejected"] = rejected_rewards.mean().cpu() + metrics[f"{prefix}rewards/accuracies"] = reward_accuracies.mean().cpu() + metrics[f"{prefix}rewards/margins"] = (chosen_rewards - rejected_rewards).mean().cpu() + # policy logps + metrics[f"{prefix}logps/rejected"] = policy_rejected_logps.detach().mean().cpu() + metrics[f"{prefix}logps/chosen"] = policy_chosen_logps.detach().mean().cpu() + # policy logits (exclude image tokens) + # metrics[f"{prefix}logits/rejected"] =policy_rejected_logits + # metrics[f"{prefix}logits/chosen"] = policy_chosen_logits + # reference logps + metrics[f"{prefix}ref_logps/rejected"] = reference_rejected_logps.mean().cpu() + metrics[f"{prefix}ref_logps/chosen"] = reference_chosen_logps.mean().cpu() + + # metrics all pick .4 digits + # for k in metrics: + # metrics[k] = round(metrics[k].item(), 4) + + return losses, metrics + + def compute_loss( + self, + model: Union[PreTrainedModel, nn.Module], + inputs: Dict[str, Union[torch.Tensor, Any]], + return_outputs=False, + ) -> Union[torch.Tensor, Tuple[torch.Tensor, Dict[str, torch.Tensor]]]: + if not self.use_dpo_data_collator: + warnings.warn( + "compute_loss is only implemented for DPODataCollatorWithPadding, and you passed a datacollator that is different than " + "DPODataCollatorWithPadding - you might see unexpected behavior. Alternatively, you can implement your own prediction_step method if you are using a custom data collator" + ) + + compute_loss_context_manager = torch.cuda.amp.autocast if self._peft_has_been_casted_to_bf16 else nullcontext + + with compute_loss_context_manager(): + loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="train") + + # force log the metrics + self.store_metrics(metrics, train_eval="train") + + if return_outputs: + return (loss, metrics) + return loss + + def get_batch_samples(self, model, batch: Dict[str, torch.LongTensor]) -> Tuple[str, str]: + """Generate samples from the model and reference model for the given batch of inputs.""" + + # If one uses `generate_during_eval` with peft + bf16, we need to explictly call generate with + # the torch cuda amp context manager as some hidden states are silently casted to full precision. + generate_context_manager = nullcontext if not self._peft_has_been_casted_to_bf16 else torch.cuda.amp.autocast + + with generate_context_manager(): + policy_output = model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.tokenizer.pad_token_id, + ) + + # if reference_output in batch use that otherwise use the reference model + if "reference_output" in batch: + reference_output = batch["reference_output"] + else: + if self.ref_model is None: + with self.null_ref_context(): + reference_output = self.model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.tokenizer.pad_token_id, + ) + else: + reference_output = self.ref_model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.tokenizer.pad_token_id, + ) + + policy_output = pad_to_length(policy_output, self.max_length, self.tokenizer.pad_token_id) + policy_output_decoded = self.tokenizer.batch_decode(policy_output, skip_special_tokens=True) + + reference_output = pad_to_length(reference_output, self.max_length, self.tokenizer.pad_token_id) + reference_output_decoded = self.tokenizer.batch_decode(reference_output, skip_special_tokens=True) + + return policy_output_decoded, reference_output_decoded + + def prediction_step( + self, + model: Union[PreTrainedModel, nn.Module], + inputs: Dict[str, Union[torch.Tensor, Any]], + prediction_loss_only: bool, + ignore_keys: Optional[List[str]] = None, + ): + if not self.use_dpo_data_collator: + warnings.warn( + "prediction_step is only implemented for DPODataCollatorWithPadding, and you passed a datacollator that is different than " + "DPODataCollatorWithPadding - you might see unexpected behavior. Alternatively, you can implement your own prediction_step method if you are using a custom data collator" + ) + if ignore_keys is None: + if hasattr(model, "config"): + ignore_keys = getattr(model.config, "keys_to_ignore_at_inference", []) + else: + ignore_keys = [] + + prediction_context_manager = torch.cuda.amp.autocast if self._peft_has_been_casted_to_bf16 else nullcontext + + with torch.no_grad(), prediction_context_manager(): + loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="eval") + + # force log the metrics + self.store_metrics(metrics, train_eval="eval") + + if prediction_loss_only: + return (loss.detach(), None, None) + + # logits for the chosen and rejected samples from model + logits_dict = { + "eval_logits/chosen": metrics["eval_logits/chosen"], + "eval_logits/rejected": metrics["eval_logits/rejected"], + } + logits = tuple(v.unsqueeze(dim=0) for k, v in logits_dict.items() if k not in ignore_keys) + logits = torch.stack(logits).mean(axis=1).to(self.accelerator.device) + labels = torch.zeros(logits.shape[0], device=self.accelerator.device) + + return (loss.detach(), logits, labels) + + def store_metrics(self, metrics: Dict[str, float], train_eval: Literal["train", "eval"] = "train") -> None: + for key, value in metrics.items(): + self._stored_metrics[train_eval][key].append(value) + + def evaluation_loop( + self, + dataloader: DataLoader, + description: str, + prediction_loss_only: Optional[bool] = None, + ignore_keys: Optional[List[str]] = None, + metric_key_prefix: str = "eval", + ) -> EvalLoopOutput: + """ + Overriding built-in evaluation loop to store metrics for each batch. + Prediction/evaluation loop, shared by `Trainer.evaluate()` and `Trainer.predict()`. + + Works both with or without labels. + """ + + # Sample and save to game log if requested (for one batch to save time) + if self.generate_during_eval: + # Generate random indices within the range of the total number of samples + num_samples = len(dataloader.dataset) + random_indices = random.sample(range(num_samples), k=self.args.eval_batch_size) + + # Use dataloader.dataset.select to get the random batch without iterating over the DataLoader + random_batch_dataset = dataloader.dataset.select(random_indices) + random_batch = self.data_collator(random_batch_dataset) + random_batch = self._prepare_inputs(random_batch) + + policy_output_decoded, ref_output_decoded = self.get_batch_samples(self.model, random_batch) + + self.log( + { + "game_log": wandb.Table( + columns=["Prompt", "Policy", "Ref Model"], + rows=[[prompt, pol[len(prompt) :], ref[len(prompt) :]] for prompt, pol, ref in zip(random_batch["prompt"], policy_output_decoded, ref_output_decoded)], + ) + } + ) + self.state.log_history.pop() + + # Base evaluation + initial_output = super().evaluation_loop(dataloader, description, prediction_loss_only, ignore_keys, metric_key_prefix) + + return initial_output + + def log(self, logs: Dict[str, float]) -> None: + """ + Log `logs` on the various objects watching training, including stored metrics. + + Args: + logs (`Dict[str, float]`): + The values to log. + """ + # logs either has 'loss' or 'eval_loss' + train_eval = "train" if "loss" in logs else "eval" + # Add averaged stored metrics to logs + for key, metrics in self._stored_metrics[train_eval].items(): + logs[key] = torch.tensor(metrics).mean().item() + del self._stored_metrics[train_eval] + return super().log(logs) + + @wraps(Trainer.push_to_hub) + def push_to_hub(self, commit_message: Optional[str] = "End of training", blocking: bool = True, **kwargs) -> str: + """ + Overwrite the `push_to_hub` method in order to force-add the tag "sft" when pushing the + model on the Hub. Please refer to `~transformers.Trainer.push_to_hub` for more details. + """ + kwargs = trl_sanitze_kwargs_for_tagging(model=self.model, tag_names=self._tag_names, kwargs=kwargs) + + return super().push_to_hub(commit_message=commit_message, blocking=blocking, **kwargs) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/iterative_sft_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/iterative_sft_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..1fd55442c7882077141d275a8f929c1b482b8ac5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/iterative_sft_trainer.py @@ -0,0 +1,334 @@ +# Copyright 2023 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import warnings +from typing import Callable, Dict, List, Optional, Tuple, Union + +import torch +from datasets import Dataset +from torch.utils.data import DataLoader +from transformers import ( + DataCollator, + DataCollatorForLanguageModeling, + DataCollatorForSeq2Seq, + PreTrainedModel, + PreTrainedTokenizerBase, + Trainer, + TrainingArguments, +) +from transformers.trainer_utils import EvalLoopOutput + +from ..core import PPODecorators +from ..import_utils import is_peft_available + + +if is_peft_available(): + from peft import PeftModel + + +class IterativeSFTTrainer(Trainer): + """ + The IterativeSFTTrainer can be used to finetune models with methods that requires some steps between optimization. + + Attributes: + **model** (`PreTrainedModel`) -- Model to be optimized, either an 'AutoModelForCausalLM' or an 'AutoModelForSeq2SeqLM'. + Check the documentation of `PreTrainedModel` for more details. + **args** (`transformers.TrainingArguments`): -- The arguments to use for training. + **tokenizer** (`PreTrainedTokenizerBase`) -- Tokenizer to be used for encoding the + data. Check the documentation of `transformers.PreTrainedTokenizer` and + `transformers.PreTrainedTokenizerFast` for more details. + **optimizers** (`Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): -- The optimizer and scheduler to use for training. + **data_collator** (Union[DataCollatorForLanguageModeling, DataCollatorForSeq2Seq], *optional*) -- Data collator to be used for training and + passed along the dataloader. + **eval_dataset** (`datasets.Dataset`): The dataset to use for evaluation. + **max_length** (`int`, defaults to `None`): -- The maximum length of the input. + **truncation_mode** (`str`, defaults to `keep_end`): -- The truncation mode to use, either `keep_end` or `keep_start`. + **preprocess_logits_for_metrics** (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): -- The function to use to preprocess the logits before computing the metrics. + **compute_metrics** (`Callable[[EvalPrediction], Dict]`, *optional*): -- The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to metric values. + **optimize_device_cache ** (`bool`, *optional*, defaults to `False`) -- Optimize CUDA cache for slightly more memory-efficient training. + """ + + def __init__( + self, + model: PreTrainedModel = None, + args: TrainingArguments = None, + tokenizer: PreTrainedTokenizerBase = None, + optimizers: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = ( + None, + None, + ), + data_collator: Optional[DataCollator] = None, + eval_dataset: Optional[Union[Dataset, Dict[str, Dataset]]] = None, + max_length: Optional[int] = None, + truncation_mode: Optional[str] = "keep_end", + preprocess_logits_for_metrics: Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None, + compute_metrics: Optional[Callable[[EvalLoopOutput], Dict]] = None, + optimize_device_cache: Optional[bool] = False, + ): + # Step 0: check positional arguments validity + if not isinstance(tokenizer, (PreTrainedTokenizerBase)): + raise ValueError(f"tokenizer must be a PreTrainedTokenizerBase like a PreTrainedTokenizer or a PreTrainedTokenizerFast, got {type(tokenizer)}") + if not isinstance(model, PreTrainedModel): + raise ValueError(f"model must be a PreTrainedModel, got {type(model)}") + if not model.can_generate(): + warnings.warn(f"The current model class {type(model)} is not compatible with `.generate()`" "Please make sure that this is intended.") + if optimizers[1] is None and args.max_steps == -1: + raise ValueError("When no scheduler is provided, you need to set the total number of training steps to perform `max_steps`") + + self.is_encoder_decoder = getattr(model.config, "is_encoder_decoder", False) + self.is_peft_model = is_peft_available() and isinstance(model, PeftModel) + + self.tokenizer = tokenizer + + if data_collator is None: + if self.is_encoder_decoder: + warnings.warn("No data collator is provided. Using 'DataCollatorForSeq2Seq' with" "'labels_pad_token_id' set to '-100' and 'pad_to_multiple_of' set to 8.") + self.data_collator = DataCollatorForSeq2Seq(tokenizer, label_pad_token_id=-100, pad_to_multiple_of=8) + else: + warnings.warn("No data collator is provided. Using 'DataCollatorForLanguageModeling'") + self.data_collator = DataCollatorForLanguageModeling(self.tokenizer, mlm=False) + else: + self.data_collator = data_collator + + self.max_length = max_length + self.truncation_mode = truncation_mode + self.optimize_device_cache = optimize_device_cache + + super().__init__( + model=model, + args=args, + data_collator=self.data_collator, + eval_dataset=eval_dataset, + tokenizer=tokenizer, + compute_metrics=compute_metrics, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + self.create_optimizer_and_scheduler(self.args.max_steps) + + # prepare model, optimizer and lr_scheduler + self.model, self.optimizer, self.lr_scheduler = self.accelerator.prepare(self.model, self.optimizer, self.lr_scheduler) + + self.tokenizer.truncation_side = "left" if self.truncation_mode == "keep_end" else "right" + + if not hasattr(self, "accelerator"): + raise AttributeError("Your `Trainer` does not have an `accelerator` object. Consider upgrading `transformers`.") + + PPODecorators.optimize_device_cache = self.optimize_device_cache + + def prepare_model_inputs(self, input_ids: torch.Tensor, attention_mask: torch.Tensor, labels: torch.Tensor): + if attention_mask is None: + attention_mask = [torch.ones_like(ids) for ids in input_ids] + + if self.is_encoder_decoder: + input_data = self.data_collator([{"input_ids": ids, "attention_mask": att, "labels": lab} for ids, att, lab in zip(input_ids, attention_mask, labels)]).to(self.model.device) + + input_data.pop("decoder_input_ids", None) # This is directly computed inside the model + + input_data["labels"][input_data["labels"] == self.tokenizer.pad_token_id] = -100 + + else: + input_data = self.data_collator([{"input_ids": ids, "attention_mask": att} for ids, att in zip(input_ids, attention_mask)]).to(self.model.device) + + # truncate in case the user has provided input_ids, attention_mask and labels + if self.max_length is not None: + if self.truncation_mode == "keep_start": + input_data = {k: v[: self.max_length] for k, v in input_data.items()} + elif self.truncation_mode == "keep_end": + input_data = {k: v[-self.max_length :] for k, v in input_data.items()} + else: + raise ValueError(f"Unknown truncation mode: {self.truncation_mode}") + + return input_data + + @staticmethod + def _step_safety_checker( + input_ids: List[torch.LongTensor], + attention_mask: List[torch.LongTensor], + labels: List[torch.LongTensor], + texts: List[str], + texts_labels: List[str], + ): + """ + Check if the input data is valid for training. + + Args: + input_ids (List[`torch.LongTensor`]): + List of tensors containing the input_ids + attention_mask (List[`torch.LongTensor`]): + List of tensors containing the attention_mask + labels (List[`torch.FloatTensor`]): + List of tensors containing the labels + texts (List[`str`]): + List of string containing the text input. + texts_labels (List[`str`]): + List of string containing the text labels. + Returns: + `tuple`: The input data. + """ + if texts is None: + if attention_mask is None: + for name, tensor_list in zip(["input_ids", "labels"], [input_ids, labels]): + if not isinstance(tensor_list, list): + raise ValueError(f"{name} must be a list of tensors - got {type(tensor_list)}") + if not isinstance(tensor_list[0], torch.Tensor): + raise ValueError(f"Elements in {name} must be tensors - got {type(tensor_list[0])}") + else: + for name, tensor_list in zip(["input_ids", "attention_mask", "labels"], [input_ids, attention_mask, labels]): + if not isinstance(tensor_list, list): + raise ValueError(f"{name} must be a list of tensors - got {type(tensor_list)}") + if not isinstance(tensor_list[0], torch.Tensor): + raise ValueError(f"Elements in {name} must be tensors - got {type(tensor_list[0])}") + else: + if not isinstance(texts, list): + raise ValueError(f"'text' must be a list of strings - got {type(texts)}") + if not isinstance(texts[0], str): + raise ValueError(f"Elements in 'text' must be strings - got {type(texts[0])}") + if texts_labels is not None: + if not isinstance(texts_labels, list): + raise ValueError(f"'text_labels' must be a list of strings - got {type(texts_labels)}") + if not isinstance(texts_labels[0], str): + raise ValueError(f"Elements in 'text_labels' must be strings - got {type(texts_labels[0])}") + + return input_ids, attention_mask, labels, texts, texts_labels + + @PPODecorators.empty_device_cache() + def step( + self, + input_ids: Optional[List[torch.LongTensor]] = None, + attention_mask: Optional[List[torch.LongTensor]] = None, + labels: Optional[List[torch.LongTensor]] = None, + texts: Optional[List[str]] = None, + texts_labels: Optional[List[str]] = None, + ): + """ + Run an optimisation step given a list of input_ids, attention_mask, and labels or a list of text and text_labels. + Args: + input_ids (List[`torch.LongTensor`]): + List of tensors containing the input_ids (if not provided, text will be used) + attention_mask (List[`torch.LongTensor`], , *optional*): + List of tensors containing the attention_mask + labels (List[`torch.FloatTensor`], *optional*): + List of tensors containing the labels (if set to None, will default to input_ids) + texts (List[`str`], *optional*): + List of strings containing the text input (if not provided, input_ids will directly be used) + texts_labels (List[`str`], *optional*): + List of strings containing the text labels (if set to None, will default to text) + Returns: + `dict[str, Any]`: A summary of the training statistics + """ + self.model.train() + + if self.state.global_step == 0: + self.tr_loss = torch.tensor(0.0).to(self.args.device) + self._globalstep_last_logged = self.state.global_step + + if input_ids is None and texts is None: + raise ValueError("Step should include `input_ids` or `texts` as keyword arguments.") + elif input_ids is not None and texts is not None: + warnings.warn("Both 'input_ids' and 'texts' are provided. 'input_ids' will be overwritten using inputs provided by the 'texts' keyword argument.") + + if labels is None and texts_labels is None and self.is_encoder_decoder: + raise ValueError("No 'labels' or 'text_labels' are provided. When using an encoder-decoder architecture, 'labels' or 'text_labels' must be passed.") + + input_ids, attention_mask, labels, texts, texts_labels = self._step_safety_checker(input_ids, attention_mask, labels, texts, texts_labels) + + if texts is not None: + model_inputs = self.tokenizer(texts, max_length=self.max_length, truncation=True, padding=True, return_tensors="pt") + + input_ids, attention_mask = model_inputs["input_ids"], model_inputs["attention_mask"] + + if texts_labels is not None: + labels = self.tokenizer(texts, max_length=self.max_length, truncation=True, padding=True, return_tensors="pt")["input_ids"] + + if labels is None: + warnings.warn("No labels are provided. Setting labels to input_ids") + labels = input_ids + + model_inputs = self.prepare_model_inputs(input_ids, attention_mask, labels) + + model_inputs_names = list(model_inputs.keys()) + + batch_dict = {} + batch_dict.update(model_inputs) + + def collator(data): + return_dict = dict() + for key in data[0]: + if key in ["input_ids", "attention_mask", "labels"]: + return_dict[key] = torch.stack([d[key] for d in data]).to(self.model.device) + return return_dict + + batch_data = Dataset.from_dict(batch_dict) + batch_data.set_format("torch") + + step_dataloader = DataLoader( + batch_data, + batch_size=self.args.per_device_train_batch_size, + shuffle=True, + collate_fn=collator, + ) + + for _, batch in enumerate(step_dataloader): + with self.accelerator.accumulate(self.model): + model_inputs = {k: batch[k] for k in model_inputs_names} + loss = self.compute_loss(self.model, model_inputs) + + if self.args.n_gpu > 1: + loss = loss.mean() + + tr_loss_step = loss.detach() + + self.accelerator.backward(loss) + + if self.accelerator.sync_gradients and self.args.max_grad_norm is not None: + self.accelerator.clip_grad_norm_( + self.model.parameters(), + self.args.max_grad_norm, + ) + + self.optimizer.step() + self.optimizer.zero_grad() + if self.lr_scheduler is not None: + self.lr_scheduler.step() + + self.state.global_step += 1 + + # update stats etc + self.tr_loss += tr_loss_step + + self._maybe_log_save_evaluate() + + def _maybe_log_save_evaluate(self): + # check if eval is required + if self.args.eval_steps is not None: + if self.state.global_step % self.args.eval_steps == 0 and self.state.global_step != 0: + self.evaluate(self.eval_dataset) + + # check if logging is required + if self.args.logging_steps is not None: + if self.state.global_step % self.args.logging_steps == 0 and self.state.global_step != 0: + logs: Dict[str, float] = {} + + tr_loss_scalar = self._nested_gather(self.tr_loss).mean().item() + + # reset tr_loss to zero + self.tr_loss -= self.tr_loss + + logs["loss"] = round(tr_loss_scalar / (self.state.global_step - self._globalstep_last_logged), 4) + logs["learning_rate"] = self._get_learning_rate() + + self._globalstep_last_logged = self.state.global_step + + self.log(logs) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/model_config.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/model_config.py new file mode 100644 index 0000000000000000000000000000000000000000..e6df85921e712a626cbfd67f8401928b35865459 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/model_config.py @@ -0,0 +1,71 @@ +from dataclasses import dataclass, field +from typing import List, Optional + +from ..core import flatten_dict + + +@dataclass +class ModelConfig: + """ + Arguments which define the model and tokenizer to load. + """ + + model_name_or_path: Optional[str] = field( + default=None, + metadata={"help": ("The model checkpoint for weights initialization.")}, + ) + model_revision: str = field( + default="main", + metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."}, + ) + torch_dtype: Optional[str] = field( + default=None, + metadata={ + "help": ("Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the " "dtype will be automatically derived from the model's weights."), + "choices": ["auto", "bfloat16", "float16", "float32"], + }, + ) + trust_remote_code: bool = field(default=False, metadata={"help": "Trust remote code when loading a model."}) + attn_implementation: Optional[str] = field( + default=None, + metadata={"help": ("Which attention implementation to use; you can run --attn_implementation=flash_attention_2, in which case you must install this manually by running `pip install flash-attn --no-build-isolation`")}, + ) + use_peft: bool = field( + default=False, + metadata={"help": ("Whether to use PEFT or not for training.")}, + ) + lora_r: Optional[int] = field( + default=16, + metadata={"help": ("LoRA R value.")}, + ) + lora_alpha: Optional[int] = field( + default=32, + metadata={"help": ("LoRA alpha.")}, + ) + lora_dropout: Optional[float] = field( + default=0.05, + metadata={"help": ("LoRA dropout.")}, + ) + lora_target_modules: Optional[List[str]] = field( + default=None, + metadata={"help": ("LoRA target modules.")}, + ) + lora_modules_to_save: Optional[List[str]] = field( + default=None, + metadata={"help": ("Model layers to unfreeze & train")}, + ) + load_in_8bit: bool = field(default=False, metadata={"help": "use 8 bit precision for the base model - works only with LoRA"}) + load_in_4bit: bool = field(default=False, metadata={"help": "use 4 bit precision for the base model - works only with LoRA"}) + + bnb_4bit_quant_type: Optional[str] = field(default="nf4", metadata={"help": "precise the quantization type (fp4 or nf4)"}) + use_bnb_nested_quant: bool = field(default=False, metadata={"help": "use nested quantization"}) + + def to_dict(self): + output_dict = {} + for key, value in self.__dict__.items(): + output_dict[key] = value + return flatten_dict(output_dict) + + def __post_init__(self): + if self.load_in_8bit and self.load_in_4bit: + raise ValueError("You can't use 8 bit and 4 bit precision at the same time") diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ppo_config.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ppo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..8642eab51a8464c290ed2af070dd04b9fcde2468 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ppo_config.py @@ -0,0 +1,175 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import json +import os +import sys +import warnings +from dataclasses import dataclass, field +from typing import Literal, Optional + +import numpy as np +import tyro +from typing_extensions import Annotated + +from trl.trainer.utils import exact_div + +from ..core import flatten_dict +from ..import_utils import is_wandb_available + + +JSONDict = Annotated[Optional[dict], tyro.conf.arg(metavar="JSON", constructor=json.loads)] + + +@dataclass +class PPOConfig: + """ + Configuration class for PPOTrainer + """ + + # common parameters + exp_name: str = os.path.basename(sys.argv[0])[: -len(".py")] + """the name of this experiment (by default is the file name without the extension name)""" + seed: int = 0 + """Seed value for random generations""" + log_with: Optional[Literal["wandb", "tensorboard"]] = None + """Log with either 'wandb' or 'tensorboard', check https://huggingface.co/docs/accelerate/usage_guides/tracking for more details""" + task_name: Optional[str] = None + """Name of task to use - used only for tracking purposes""" + model_name: Optional[str] = "gpt2" + """Name of model to use - used only for tracking purposes""" + query_dataset: Optional[str] = "imdb" + """Name of dataset to query - used only for tracking purposes""" + reward_model: Optional[str] = "sentiment-analysis:lvwerra/distilbert-imdb" + """The reward model to use - used only for tracking purposes""" + remove_unused_columns: bool = True + """Remove unused columns from the dataset if `datasets.Dataset` is used""" + tracker_kwargs: JSONDict = field(default_factory=dict) + """Keyword arguments for the tracker (e.g. python ppo.py --tracker_kwargs='{"wandb": {"entity": "my_wandb_entity", "name": "my_exp_name"}}'""" + accelerator_kwargs: JSONDict = field(default_factory=dict) + """Keyword arguments for the accelerator""" + project_kwargs: JSONDict = field(default_factory=dict) + """Keyword arguments for the accelerator project config (e.g. `logging_dir`)""" + tracker_project_name: str = "trl" + """Name of project to use for tracking""" + push_to_hub_if_best_kwargs: JSONDict = field(default_factory=dict) + """Keyword arguments for pushing model to the hub during training (e.g. repo_id)""" + + # hyperparameters + steps: int = 20000 + """Number of training steps""" + learning_rate: float = 1.41e-5 + """Adam learning rate""" + adap_kl_ctrl: bool = True + """Use adaptive KL control, otherwise linear""" + init_kl_coef: Optional[float] = 0.2 + """Initial KL penalty coefficient (used for adaptive and linear control)""" + kl_penalty: Literal["kl", "abs", "mse", "full"] = "kl" + """kl penalty options: 'kl': model_logp - ref_logp, 'abs': abs(kl), 'mse': mean squared error mse(kl) and 'full': the actual kl for all tokens in the distribution""" + target: Optional[float] = 6 + """Target KL value for adaptive KL control""" + horizon: Optional[float] = 10000 + """Horizon for adaptive KL control""" + gamma: float = 1 + """Gamma parameter for advantage calculation""" + lam: float = 0.95 + """Lambda parameter for advantage calculation""" + cliprange: float = 0.2 + """Range for clipping in PPO policy gradient loss""" + cliprange_value: float = 0.2 + """Range for clipping values in loss calculation""" + vf_coef: float = 0.1 + """Scaling factor for value loss""" + batch_size: int = 128 + """Number of samples per optimisation step""" + forward_batch_size: Optional[int] = None + """DEPRECATED: use `mini_batch_size` instead, which does the same thing.""" + mini_batch_size: int = 128 + """Number of samples optimized in each mini batch""" + gradient_accumulation_steps: int = 1 + """The number of gradient accumulation steps""" + world_size: tyro.conf.Suppress[int] = None + """The world size for distributed training""" + ppo_epochs: int = 4 + """Number of optimisation epochs per batch of samples""" + max_grad_norm: Optional[float] = None + """Maximum gradient norm for gradient clipping""" + optimize_cuda_cache: Optional[bool] = None + """DEPRECATED: use `optimize_device_cache` instead, which does the same thing.""" + optimize_device_cache: Optional[bool] = False + """Optimize device cache for slightly more memory-efficient training""" + early_stopping: bool = False + """Whether to stop the PPO optimization loop early is the KL too high""" + target_kl: float = 1 + """Stop early if we exceed this value by over 50%""" + compare_steps: int = 1 + """Number of steps between comparison of the current reward with the best seen so far""" + ratio_threshold: float = 10.0 + """Skip mini-batches with high PPO ratios that can cause loss spikes""" + use_score_scaling: bool = False + """Use score scaling""" + use_score_norm: bool = False + """Use score normalization. Only applicable if use_score_scaling is True""" + score_clip: Optional[float] = None + """Score clipping""" + whiten_rewards: bool = False + """Whiten the rewards before compute advantages""" + + # computed hyperparameters at runtime; we use `tyro.conf.Suppress` to hide them from the help text + is_encoder_decoder: Optional[tyro.conf.Suppress[bool]] = None + """TO BE FILLED In RUNTIME: Whether the model is an encoder-decoder model""" + is_peft_model: Optional[tyro.conf.Suppress[bool]] = None + """TO BE FILLED In RUNTIME: Whether the model is a PEFT model""" + backward_batch_size: tyro.conf.Suppress[int] = None + """TO BE FILLED In RUNTIME: Number of samples optimized in an `optimizer.step()` call""" + global_backward_batch_size: tyro.conf.Suppress[int] = None + """TO BE FILLED In RUNTIME: the effective `backward_batch_size` across all processes""" + global_batch_size: tyro.conf.Suppress[int] = None + """TO BE FILLED In RUNTIME: the effective `batch_size` across all processes""" + + if optimize_cuda_cache is not None: + warnings.warn("The `optimize_cuda_cache` argument will be deprecated soon, please use `optimize_device_cache` instead.") + optimize_device_cache = optimize_cuda_cache + else: + optimize_device_cache = False + + def __post_init__(self): + if self.forward_batch_size is not None: + warnings.warn( + "Note that using `forward_batch_size` is deprecated, use `mini_batch_size` instead. By setting it you overwrite `mini_batch_size` which affects both the batch size during forward passes and also the mini batch size for PPO optimization." + ) + self.mini_batch_size = self.forward_batch_size + + self.backward_batch_size = self.mini_batch_size * self.gradient_accumulation_steps + exact_div( + self.batch_size, + self.backward_batch_size, + "`batch_size`", + "`mini_batch_size * gradient_accumulation_steps`", + "`batch_size` must be a multiple of `mini_batch_size * gradient_accumulation_steps`", + ) + + # check if wandb is installed + if self.log_with == "wandb": + # raise error if wandb is not installed + if not is_wandb_available(): + raise ImportError("Please install wandb to use wandb logging. You can do this by running `pip install wandb`.") + + self.total_ppo_epochs = int(np.ceil(self.steps / self.batch_size)) + assert self.kl_penalty in ["kl", "abs", "mse", "full"] + + def to_dict(self): + output_dict = {} + for key, value in self.__dict__.items(): + output_dict[key] = value + return flatten_dict(output_dict) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ppo_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ppo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..ce7e09397ce8b58088a82730c8b4cebb60020f07 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/ppo_trainer.py @@ -0,0 +1,1397 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import inspect +import math +import os +import time +import typing +import warnings +from contextlib import nullcontext +from typing import Callable, List, Optional, Union + +import datasets +import numpy as np +import torch +import torch.nn.functional as F +from accelerate import Accelerator +from accelerate.utils import ProjectConfiguration, gather_object, is_deepspeed_available +from datasets import Dataset +from huggingface_hub import whoami +from packaging import version +from torch.optim import Adam +from transformers import ( + DataCollatorForLanguageModeling, + PreTrainedTokenizer, + PreTrainedTokenizerBase, + PreTrainedTokenizerFast, +) + +from ..core import ( + WANDB_PADDING, + PPODecorators, + clip_by_value, + convert_to_scalar, + entropy_from_logits, + flatten_dict, + logprobs_from_logits, + masked_mean, + masked_var, + masked_whiten, + set_seed, + stack_dicts, + stats_to_np, +) +from ..import_utils import is_npu_available, is_torch_greater_2_0, is_xpu_available +from ..models import SUPPORTED_ARCHITECTURES, PreTrainedModelWrapper, create_reference_model +from . import AdaptiveKLController, BaseTrainer, FixedKLController, PPOConfig, RunningMoments + + +if is_deepspeed_available(): + import deepspeed + +MODEL_CARD_TEMPLATE = """--- +license: apache-2.0 +tags: +- trl +- ppo +- transformers +- reinforcement-learning +--- + +# {model_name} + +This is a [TRL language model](https://github.com/huggingface/trl) that has been fine-tuned with reinforcement learning to + guide the model outputs according to a value, function, or human feedback. The model can be used for text generation. + +## Usage + +To use this model for inference, first install the TRL library: + +```bash +python -m pip install trl +``` + +You can then generate text as follows: + +```python +from transformers import pipeline + +generator = pipeline("text-generation", model="{model_id}") +outputs = generator("Hello, my llama is cute") +``` + +If you want to use the model for training or to obtain the outputs from the value head, load the model as follows: + +```python +from transformers import AutoTokenizer +from trl import AutoModelForCausalLMWithValueHead + +tokenizer = AutoTokenizer.from_pretrained("{model_id}") +model = AutoModelForCausalLMWithValueHead.from_pretrained("{model_id}") + +inputs = tokenizer("Hello, my llama is cute", return_tensors="pt") +outputs = model(**inputs, labels=inputs["input_ids"]) +``` +""" + + +class PPOTrainer(BaseTrainer): + """ + The PPOTrainer uses Proximal Policy Optimization to optimise language models. + Note, this trainer is heavily inspired by the original OpenAI learning to summarize work here: + https://github.com/openai/summarize-from-feedback + + Attributes: + **config** (`PPOConfig`) -- Configuration object for PPOTrainer. Check the documentation of `PPOConfig` for more + details. + **model** (`PreTrainedModelWrapper`) -- Model to be optimized, Hugging Face transformer model with a value head. + Check the documentation of `PreTrainedModelWrapper` for more details. + **ref_model** (`PreTrainedModelWrapper`, *optional*) -- Reference model to be used for KL penalty, Hugging Face + transformer model with a casual language modelling head. Check the documentation of `PreTrainedModelWrapper` + for more details. If no reference model is provided, the trainer will create a reference model with the same + architecture as the model to be optimized with shared layers. + **tokenizer** (`PreTrainedTokenizerBase`) -- Tokenizer to be used for encoding the + data. Check the documentation of `transformers.PreTrainedTokenizer` and + `transformers.PreTrainedTokenizerFast` for more details. + **dataset** (Union[`torch.utils.data.Dataset`, `datasets.Dataset`], *optional*) -- PyTorch dataset or Hugging + Face dataset. This is used to create a PyTorch dataloader. If no dataset is provided, the dataloader must be + created outside the trainer users needs to design their own dataloader and make sure the batch + size that is used is the same as the one specified in the configuration object. + **optimizer** (`torch.optim.Optimizer`, *optional*) -- Optimizer to be used for training. If no optimizer is + provided, the trainer will create an Adam optimizer with the learning rate specified in the configuration + object. + **data_collator** (DataCollatorForLanguageModeling, *optional*) -- Data collator to be used for training and + passed along the dataloader + **num_shared_layers** (int, *optional*) -- Number of layers to be shared between the model and the reference + model, if no reference model is passed. If no number is provided, all the layers will be shared. + **lr_scheduler** (`torch.optim.lr_scheduler`, *optional*) -- Learning rate scheduler to be used for training. + """ + + _tag_names = ["trl", "ppo"] + + def __init__( + self, + config: PPOConfig = None, + model: PreTrainedModelWrapper = None, + ref_model: Optional[PreTrainedModelWrapper] = None, + tokenizer: PreTrainedTokenizerBase = None, + dataset: Optional[Union[torch.utils.data.Dataset, Dataset]] = None, + optimizer: Optional[torch.optim.Optimizer] = None, + data_collator: Optional[typing.Callable] = None, + num_shared_layers: Optional[int] = None, + lr_scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None, + ): + """ + Initialize PPOTrainer. + + Args: + config (`PPOConfig`): + Configuration object for PPOTrainer. Check the documentation of `PPOConfig` for more details. + model (`PreTrainedModelWrapper`): + Hugging Face transformer model with a value head. + ref_model (`PreTrainedModelWrapper`): + Hugging Face transformer model with a casual language modelling head. Used for KL penalty + tokenizer (`transformers.PreTrainedTokenizerBase`): + Hugging Face tokenizer + dataset (Optional[Union[`torch.utils.data.Dataset`, `datasets.Dataset`]]): + PyTorch dataset or Hugging Face dataset. If a Hugging Face dataset is passed, the dataset + will be preprocessed by removing the columns that are not used by the model. If none is passed, + a warning will be raised in a multi-GPU setting. + optimizer (Optional[`torch.optim.Optimizer`]): + Optimizer used for training. If `None`, the `Adam` is used as default. + data_collator (Optional[function]): + Data collator function. + num_shared_layers (Optional[int]): + Number of shared layers between the model and the reference model. If `None`, all layers are shared. + used only if `ref_model` is `None`. + lr_scheduler (Optional[`torch.optim.lr_scheduler`]): + Learning rate scheduler used for training. + """ + super().__init__(config) + + # initial seed for reproducible experiments + set_seed(config.seed) + + # Step 0: check positional arguments validity + if not isinstance(config, PPOConfig): + raise ValueError(f"config must be a PPOConfig, got {type(config)}") + if not isinstance(tokenizer, (PreTrainedTokenizerBase)): + raise ValueError(f"tokenizer must be a PreTrainedTokenizerBase like a PreTrainedTokenizer or a PreTrainedTokenizerFast, got {type(tokenizer)}") + if not isinstance(model, (SUPPORTED_ARCHITECTURES)): + raise ValueError(f"model must be a PreTrainedModelWrapper, got {type(model)} - supported architectures are: {SUPPORTED_ARCHITECTURES}") + # Step 1: Initialize Accelerator + self.accelerator = Accelerator( + log_with=config.log_with, + gradient_accumulation_steps=config.gradient_accumulation_steps, + project_config=ProjectConfiguration(**config.project_kwargs), + **config.accelerator_kwargs, + ) + + # Step 1.1 Runtime variables filled by the accelerator + config.world_size = self.accelerator.num_processes + config.global_backward_batch_size = config.backward_batch_size * config.world_size + config.global_batch_size = config.batch_size * config.world_size + + self.model = model + self.model_params = filter(lambda p: p.requires_grad, self.model.parameters()) + self.is_encoder_decoder = hasattr(self.model, "is_encoder_decoder") + self.is_peft_model = getattr(self.model, "is_peft_model", False) + config.is_encoder_decoder = self.is_encoder_decoder + config.is_peft_model = self.is_peft_model + + is_using_tensorboard = config.log_with is not None and config.log_with == "tensorboard" + self.accelerator.init_trackers( + config.tracker_project_name, + config=dict(trl_ppo_trainer_config=config.to_dict()) if not is_using_tensorboard else config.to_dict(), + init_kwargs=config.tracker_kwargs, + ) + self.is_using_text_environment = getattr(config, "use_text_environment", False) + + if isinstance(ref_model, SUPPORTED_ARCHITECTURES): + self.ref_model = ref_model + if num_shared_layers is not None: + warnings.warn( + "num_shared_layers is ignored when ref_model is provided. Two different models are used for the " "model and the reference model and no layers are shared.", + UserWarning, + ) + elif ref_model is None and not self.is_peft_model: + self.ref_model = create_reference_model(self.model, num_shared_layers=num_shared_layers) + elif self.is_peft_model: + self.ref_model = None + else: + raise ValueError(f"ref_model must be a PreTrainedModelWrapper or `None`, got {type(ref_model)} - supported " f"architectures are: {SUPPORTED_ARCHITECTURES} ") + self.optional_peft_ctx = self.accelerator.unwrap_model(self.model).pretrained_model.disable_adapter if self.is_peft_model else nullcontext + + if not (isinstance(tokenizer, PreTrainedTokenizer) or isinstance(tokenizer, PreTrainedTokenizerFast)): + raise ValueError("tokenizer must be a transformers.PreTrainedTokenizer or transformers.PreTrainedTokenizerFast") + self.tokenizer = tokenizer + + if dataset is not None and not (isinstance(dataset, torch.utils.data.Dataset) or isinstance(dataset, Dataset)): + raise ValueError("dataset must be a torch.utils.data.Dataset or datasets.Dataset") + elif dataset is None: + warnings.warn( + "No dataset is provided. Make sure to set config.batch_size to the correct value before training.", + UserWarning, + ) + self.dataset = dataset + self._signature_columns = None + if self.dataset is not None: + self.dataloader = self.prepare_dataloader(self.dataset, data_collator) + elif self.dataset is None and self.accelerator.num_processes > 1: + warnings.warn( + "No dataset is provided. In a multi-GPU setting, this will lead to an error. You should" + " prepare your dataloader yourself with `dataloader = ppo_trainer.accelerator.prepare(dataloader)`" + " and using `torch.utils.data.DataLoader`, or pass a dataset to the `PPOTrainer`. Please " + " refer to the documentation for more details.", + UserWarning, + ) + self.dataloader = None + else: + self.dataloader = None + + # Step 3: Initialize optimizer and data collator + self.data_collator = DataCollatorForLanguageModeling(self.tokenizer, mlm=False) + if optimizer is None: + self.optimizer = Adam( + filter(lambda p: p.requires_grad, self.model.parameters()), + lr=self.config.learning_rate, + ) + else: + self.optimizer = optimizer + + self.lr_scheduler = lr_scheduler + if self.lr_scheduler is not None: + lr_scheduler_class = torch.optim.lr_scheduler._LRScheduler if not is_torch_greater_2_0() else torch.optim.lr_scheduler.LRScheduler + + if not isinstance(self.lr_scheduler, lr_scheduler_class): + raise ValueError("lr_scheduler must be a torch.optim.lr_scheduler._LRScheduler or torch.optim.lr_scheduler.LRScheduler (for torch >= 2.0)") + + if self.config.adap_kl_ctrl: + self.kl_ctl = AdaptiveKLController(self.config.init_kl_coef, self.config.target, self.config.horizon) + else: + self.kl_ctl = FixedKLController(self.config.init_kl_coef) + + # Safety checkers for DS integration + is_deepspeed_used = self.accelerator.distributed_type == "DEEPSPEED" and hasattr(self.accelerator.state, "deepspeed_plugin") + + ( + self.model, + self.optimizer, + self.data_collator, + self.dataloader, + self.lr_scheduler, + ) = self.accelerator.prepare( + self.model, + self.optimizer, + self.data_collator, + self.dataloader, + self.lr_scheduler, + ) + if is_deepspeed_used: + # Quantized models are already set on the correct device + if not self.is_peft_model and not (getattr(self.ref_model.pretrained_model, "is_loaded_in_8bit", False) or getattr(self.ref_model.pretrained_model, "is_loaded_in_4bit", False)): + self.ref_model = self._prepare_deepspeed(self.ref_model) + else: + self.ref_model = self.accelerator.prepare(self.ref_model) + + # In a distributed setup, only logging needs to be performed on the main process + # check: https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html + # or: https://discuss.pytorch.org/t/use-distributed-data-parallel-correctly/82500/11 + self.is_distributed = self.accelerator.num_processes > 1 + + # init the current step + self.current_step = 0 + + # init variables for pushing model to hub + if config.push_to_hub_if_best_kwargs: + if "repo_id" not in config.push_to_hub_if_best_kwargs: + raise ValueError("You have to specify repo_id in order to push the model to the hub!") + self.push_to_hub_kwargs = config.push_to_hub_if_best_kwargs + self.compare_step = 0 + self.highest_reward = torch.tensor(-float("inf")) + + # post process for PP + if not getattr(self.model, "is_sequential_parallel", False): + self.current_device = self.accelerator.device + else: + if is_xpu_available(): + self.current_device = torch.device("xpu:0") + elif is_npu_available(): + self.current_device = torch.device("npu:0") + else: + self.current_device = torch.device("cuda:0") + + PPODecorators.optimize_device_cache = self.config.optimize_device_cache + + self.running = RunningMoments(self.accelerator) + + def _filter_kwargs(self, kwargs, target_func): + """ + filter the keyword arguments that are supported by the target function. + + Args: + kwargs (dict): + Keyword arguments + target_func (function): + Target function + """ + return {k: v for k, v in kwargs.items() if k in inspect.signature(target_func).parameters.keys()} + + def prepare_dataloader(self, dataset: Union[torch.utils.data.Dataset, Dataset], data_collator=None): + """ + Prepare the dataloader for training. + + Args: + dataset (Union[`torch.utils.data.Dataset`, `datasets.Dataset`]): + PyTorch dataset or Hugging Face dataset. If a Hugging Face dataset is passed, the dataset + will be preprocessed by removing the columns that are not used by the model. + data_collator (Optional[function]): + Data collator function. + + Returns: + `torch.utils.data.DataLoader`: PyTorch dataloader + """ + if isinstance(dataset, Dataset): + dataset = self._remove_unused_columns(dataset) + dataloader = torch.utils.data.DataLoader( + dataset, + batch_size=self.config.batch_size, + collate_fn=data_collator, + shuffle=True, + drop_last=True, + ) + return dataloader + + # Adapted from transformers.Trainer._set_signature_columns_if_needed + def _set_signature_columns_if_needed(self): + if self._signature_columns is None: + # Inspect model forward signature to keep only the arguments it accepts. + signature = inspect.signature(self.model.forward) + self._signature_columns = list(signature.parameters.keys()) + # label => sentiment | we need query and response for logging purpose + self._signature_columns += ["label", "query", "response"] + + # Adapted from transformers.Trainer._remove_unused_columns + def _remove_unused_columns(self, dataset: "Dataset"): + if not self.config.remove_unused_columns: + return dataset + self._set_signature_columns_if_needed() + signature_columns = self._signature_columns + + ignored_columns = list(set(dataset.column_names) - set(signature_columns)) + + columns = [k for k in signature_columns if k in dataset.column_names] + + if version.parse(datasets.__version__) < version.parse("1.4.0"): + dataset.set_format( + type=dataset.format["type"], + columns=columns, + format_kwargs=dataset.format["format_kwargs"], + ) + return dataset + else: + return dataset.remove_columns(ignored_columns) + + def generate( + self, + query_tensor: Union[torch.Tensor, List[torch.Tensor]], + length_sampler: Callable = None, + batch_size: int = 4, + return_prompt: bool = True, + generate_ref_response: bool = False, + **generation_kwargs, + ): + """ + Generate response with the model given the query tensor. + call the `generate` method of the model. + + Args: + query_tensor (`torch.LongTensor`): + A tensor of shape (`seq_len`) containing query tokens or a list of tensors of shape (`seq_len`). + length_sampler (`Callable`, *optional*): + Callable that returns the number of newly generated tokens. + batch_size (`int`, *optional): + Batch size used for generation, defaults to `4`. + return_prompt (`bool`, *optional*): + If set to `False` the prompt is not returned but only the newly generated tokens, defaults to `True`. + generate_ref_response (`bool`, *optional*): + If set to `True` the reference response is also generated, defaults to `False`. + generation_kwargs (dict[str, Any]): + Keyword arguments for generation. + + Returns: + `torch.LongTensor`: A tensor of shape (`batch_size`, `gen_len`) containing response tokens. + """ + if generate_ref_response: + ref_model = self.model if self.is_peft_model else self.ref_model + if isinstance(query_tensor, List): + response = self._generate_batched( + self.model, + query_tensor, + length_sampler=length_sampler, + batch_size=batch_size, + return_prompt=return_prompt, + **generation_kwargs, + ) + if generate_ref_response: + with self.optional_peft_ctx(): + ref_response = self._generate_batched( + ref_model, + query_tensor, + length_sampler=length_sampler, + batch_size=batch_size, + return_prompt=return_prompt, + **generation_kwargs, + ) + + else: + if len(query_tensor.shape) == 2: + raise ValueError("query_tensor must be a tensor of shape (`seq_len`) or a list of tensors of shape (`seq_len`)") + + if length_sampler is not None: + generation_kwargs["max_new_tokens"] = length_sampler() + response = self.accelerator.unwrap_model(self.model).generate(input_ids=query_tensor.unsqueeze(dim=0), **generation_kwargs) + if generate_ref_response: + with self.optional_peft_ctx(): + ref_response = ref_model.generate(input_ids=query_tensor.unsqueeze(dim=0), **generation_kwargs) + + if not return_prompt and not self.is_encoder_decoder: + response = response[:, query_tensor.shape[0] :] + if generate_ref_response: + ref_response = ref_response[:, query_tensor.shape[0] :] + + if generate_ref_response: + return response, ref_response + return response + + def _generate_batched( + self, + model: PreTrainedModelWrapper, + query_tensors: List[torch.Tensor], + length_sampler: Callable = None, + batch_size: int = 4, + return_prompt: bool = True, + pad_to_multiple_of: int = None, + remove_padding: bool = True, + **generation_kwargs, + ): + outputs = [] + + padding_side_default = self.tokenizer.padding_side + if not self.is_encoder_decoder: + self.tokenizer.padding_side = "left" + + # in case we have fewer examples than bs + batch_size = min(len(query_tensors), batch_size) + + for i in range(0, len(query_tensors), batch_size): + if length_sampler is not None: + generation_kwargs["max_new_tokens"] = length_sampler() + + # prevent overflow if query tensors are not even multiple of bs + end_index = min(len(query_tensors), i + batch_size) + + batch = query_tensors[i:end_index] + batch_mask = [torch.ones_like(element) for element in batch] + inputs = {"input_ids": batch, "attention_mask": batch_mask} + + padded_inputs = self.tokenizer.pad( + inputs, + padding=True, + max_length=None, + pad_to_multiple_of=pad_to_multiple_of, + return_tensors="pt", + ).to(self.current_device) + + generations = self.accelerator.unwrap_model(model).generate(**padded_inputs, **generation_kwargs) + + for generation, mask in zip(generations, padded_inputs["attention_mask"]): + if not self.is_encoder_decoder: + output = generation[(1 - mask).sum() :] # remove padding + else: + output = generation + + if not return_prompt and not self.is_encoder_decoder: + output = output[(mask).sum() :] # remove prompt + + if remove_padding and self.tokenizer.eos_token_id in output: + pad_mask = output == self.tokenizer.eos_token_id + pad_start = torch.nonzero(pad_mask, as_tuple=False)[0, 0].item() + output = output[: pad_start + 1] # keep the eos token at the end + + outputs.append(output) + + self.tokenizer.padding_side = padding_side_default + return outputs + + def _step_safety_checker( + self, + batch_size: int, + queries: List[torch.LongTensor], + responses: List[torch.LongTensor], + scores: List[torch.FloatTensor], + masks: Optional[List[torch.LongTensor]] = None, + ): + """ + Check if the input data is valid for training. + + Args: + batch_size (int): + Batch size from the config file. + queries (List[`torch.LongTensor`]): + List of tensors containing the encoded queries of shape (`query_length`) + responses (List[`torch.LongTensor`]): + List of tensors containing the encoded responses of shape (`response_length`) + scores (List[`torch.FloatTensor`]): + List of tensors containing the scores. + masks (List[`torch.LongTensor`], *optional*): + list of optional tensors containing the masks of shape (`query_length` + `response_length`) + Returns: + `tuple`: The input processed data. + """ + for name, tensor_list in zip(["queries", "responses", "scores"], [queries, responses, scores]): + if not isinstance(tensor_list, list): + raise ValueError(f"{name} must be a list of tensors - got {type(tensor_list)}") + if not isinstance(tensor_list[0], torch.Tensor): + raise ValueError(f"Elements in {name} must be tensors - got {type(tensor_list[0])}") + if batch_size is not None and len(tensor_list) != batch_size: + raise ValueError(f"Batch size ({batch_size}) does not match number of examples - but got {len(tensor_list)} for: {name}") + + # add queries, scores and responses on the correct device + queries = [tensor.to(self.current_device) for tensor in queries] + responses = [tensor.to(self.current_device) for tensor in responses] + scores = [tensor.to(self.current_device) for tensor in scores] + masks = [tensor.to(self.current_device) for tensor in masks] if masks is not None else None + + # squeeze scores if needed + for i, score in enumerate(scores): + if score.dim() > 1: + raise ValueError(f"Scores must be 1-dimensional - got {score.dim()} for {score}") + elif score.dim() == 1: + scores[i] = score.squeeze() + + return queries, responses, scores, masks + + @PPODecorators.empty_device_cache() + def step( + self, + queries: List[torch.LongTensor], + responses: List[torch.LongTensor], + scores: List[torch.FloatTensor], + response_masks: Optional[List[torch.LongTensor]] = None, + ): + """ + Run a PPO optimisation step given a list of queries, model responses, and rewards. + + Args: + queries (List[`torch.LongTensor`]): + List of tensors containing the encoded queries of shape (`query_length`) + responses (List[`torch.LongTensor`]): + List of tensors containing the encoded responses of shape (`response_length`) + scores (List[`torch.FloatTensor`]): + List of tensors containing the scores. + response_masks (List[`torch.FloatTensor`], *optional*)): + List of tensors containing masks of the response tokens. + + Returns: + `dict[str, Any]`: A summary of the training statistics + """ + bs = self.config.batch_size + + queries, responses, scores, response_masks = self._step_safety_checker(bs, queries, responses, scores, response_masks) + scores = torch.tensor(scores, device=self.current_device) + if self.config.use_score_scaling: + # Score scaling + scores_mean, scores_std = self.running.update(scores) + tensor_to_kwargs = dict(dtype=scores.dtype, device=scores.device) + score_scaling_factor = self.running.std.to(**tensor_to_kwargs) + torch.finfo(scores.dtype).eps + if self.config.use_score_norm: + scores = (scores - self.running.mean.to(**tensor_to_kwargs)) / score_scaling_factor + else: + scores /= score_scaling_factor + + if self.config.score_clip is not None: + # Score clipping + scores_dtype = scores.dtype + scores = torch.clip(scores.float(), -self.config.score_clip, self.config.score_clip).to(dtype=scores_dtype) + + # if we want to push best model to the hub + if hasattr(self, "highest_reward"): + if self.compare_step % self.config.compare_steps == 0: + curr_mean_reward = scores.mean() + # if the best reward ever seen + if curr_mean_reward > self.highest_reward: + self.highest_reward = curr_mean_reward + # push model to hub + self.push_to_hub(**self.push_to_hub_kwargs) + self.compare_step += 1 + + timing = dict() + t0 = time.time() + + t = time.time() + + model_inputs = self.prepare_model_inputs(queries, responses) + + if self.is_distributed: + pad_first = self.tokenizer.padding_side == "left" + + model_inputs["input_ids"] = self.accelerator.pad_across_processes( + model_inputs["input_ids"], + dim=1, + pad_index=self.tokenizer.pad_token_id, + pad_first=pad_first, + ) + model_inputs["attention_mask"] = self.accelerator.pad_across_processes(model_inputs["attention_mask"], dim=1, pad_index=0, pad_first=pad_first) + if self.is_encoder_decoder: + model_inputs["decoder_input_ids"] = self.accelerator.pad_across_processes( + model_inputs["decoder_input_ids"], + dim=1, + pad_index=self.tokenizer.pad_token_id, + pad_first=pad_first, + ) + model_inputs["decoder_attention_mask"] = self.accelerator.pad_across_processes( + model_inputs["decoder_attention_mask"], + dim=1, + pad_index=0, + pad_first=pad_first, + ) + + model_inputs_names = list(model_inputs.keys()) + + full_kl_penalty = self.config.kl_penalty == "full" + + with torch.no_grad(): + all_logprobs, logits_or_none, values, masks = self.batched_forward_pass( + self.model, + queries, + responses, + model_inputs, + response_masks=response_masks, + return_logits=full_kl_penalty, + ) + with self.optional_peft_ctx(): + ref_logprobs, ref_logits_or_none, _, _ = self.batched_forward_pass( + self.model if self.is_peft_model else self.ref_model, + queries, + responses, + model_inputs, + return_logits=full_kl_penalty, + ) + + timing["time/ppo/forward_pass"] = time.time() - t + + with torch.no_grad(): + t = time.time() + if full_kl_penalty: + active_full_logprobs = logprobs_from_logits(logits_or_none, None, gather=False) + ref_full_logprobs = logprobs_from_logits(ref_logits_or_none, None, gather=False) + + rewards, non_score_reward, kls = self.compute_rewards(scores, active_full_logprobs, ref_full_logprobs, masks) + else: + rewards, non_score_reward, kls = self.compute_rewards(scores, all_logprobs, ref_logprobs, masks) + timing["time/ppo/compute_rewards"] = time.time() - t + + t = time.time() + values, advantages, returns = self.compute_advantages(values, rewards, masks) + timing["time/ppo/compute_advantages"] = time.time() - t + + # upcast to float32 to avoid dataset issues + batch_dict = { + "queries": queries, + "responses": responses, + "logprobs": all_logprobs.to(torch.float32), + "values": values.to(torch.float32), + "masks": masks, + "advantages": advantages, + "returns": returns, + } + batch_dict.update(model_inputs) + + t = time.time() + all_stats = [] + early_stop = False + for _ in range(self.config.ppo_epochs): + if early_stop: + break + b_inds = np.random.permutation(bs) + for backward_batch_start in range(0, bs, self.config.backward_batch_size): + backward_batch_end = backward_batch_start + self.config.backward_batch_size + backward_batch_inds = b_inds[backward_batch_start:backward_batch_end] + + for mini_batch_start in range(0, self.config.backward_batch_size, self.config.mini_batch_size): + mini_batch_end = mini_batch_start + self.config.mini_batch_size + mini_batch_inds = backward_batch_inds[mini_batch_start:mini_batch_end] + mini_batch_dict = { + "logprobs": batch_dict["logprobs"][mini_batch_inds], + "values": batch_dict["values"][mini_batch_inds], + "masks": batch_dict["masks"][mini_batch_inds], + # hacks: the queries and responses are ragged. + "queries": [batch_dict["queries"][i] for i in mini_batch_inds], + "responses": [batch_dict["responses"][i] for i in mini_batch_inds], + "advantages": batch_dict["advantages"][mini_batch_inds], + "returns": batch_dict["returns"][mini_batch_inds], + } + for k in model_inputs_names: + mini_batch_dict[k] = batch_dict[k][mini_batch_inds] + with self.accelerator.accumulate(self.model): + model_inputs = {k: mini_batch_dict[k] for k in model_inputs_names} + + logprobs, logits, vpreds, _ = self.batched_forward_pass( + self.model, + mini_batch_dict["queries"], + mini_batch_dict["responses"], + model_inputs, + return_logits=True, + ) + train_stats = self.train_minibatch( + mini_batch_dict["logprobs"], + mini_batch_dict["values"], + logprobs, + logits, + vpreds, + mini_batch_dict["masks"], + mini_batch_dict["advantages"], + mini_batch_dict["returns"], + ) + all_stats.append(train_stats) + + # typically, early stopping is done at the epoch level + if self.config.early_stopping: + policykl = train_stats["policy/policykl"] + early_stop = self._early_stop(policykl) + if early_stop: + break + + timing["time/ppo/optimize_step"] = time.time() - t + + t = time.time() + train_stats = stack_dicts(all_stats) + + # reshape advantages/ratios such that they are not averaged. + train_stats["policy/advantages"] = torch.flatten(train_stats["policy/advantages"]).unsqueeze(0) + train_stats["policy/advantages"] = torch.nan_to_num(train_stats["policy/advantages"], WANDB_PADDING) + train_stats["policy/ratio"] = torch.flatten(train_stats["policy/ratio"]).unsqueeze(0) + + stats = self.record_step_stats( + scores=scores, + logprobs=all_logprobs, + ref_logprobs=ref_logprobs, + non_score_reward=non_score_reward, + train_stats=train_stats, + kl_coef=self.kl_ctl.value, + masks=masks, + queries=queries, + responses=responses, + kls=kls, + ) + # Gather/Reduce stats from all processes + if self.is_distributed: + stats = self.gather_stats(stats) + stats = stats_to_np(stats) + timing["time/ppo/calc_stats"] = time.time() - t + stats["ppo/learning_rate"] = self.optimizer.param_groups[0]["lr"] + + # Update the KL control - multiply the batch_size by the number of processes + self.kl_ctl.update( + stats["objective/kl"], + self.config.batch_size * self.accelerator.num_processes, + ) + + # Log the total ppo time + timing["time/ppo/total"] = time.time() - t0 + stats.update(timing) + + # post-process stats for tensorboard and other loggers + if self.config.log_with != "wandb": + stats = convert_to_scalar(stats) + + if self.lr_scheduler is not None: + self.lr_scheduler.step() + + return stats + + def _early_stop(self, policykl): + r""" + Handles the early stopping logic. If the policy KL is greater than the target KL, then the gradient is zeroed and + the optimization step is skipped. + This also handles the multi-gpu case where the policy KL is averaged across all processes. + + Args: + policy_kl (torch.Tensor): + the policy KL + + Returns: + `bool`: whether to early stop or not + """ + early_stop = False + if not self.config.early_stopping: + return early_stop + + if not self.is_distributed and policykl > 1.5 * self.config.target_kl: + self.optimizer.zero_grad() + early_stop = True + elif self.is_distributed: + import torch.distributed as dist + + # Wait for all processes to finish + dist.barrier() + + # all gather the policykl + dist.all_reduce(policykl, dist.ReduceOp.SUM) + policykl /= self.accelerator.num_processes + + if policykl > 1.5 * self.config.target_kl: + self.optimizer.zero_grad() + early_stop = True + return early_stop + + def gather_stats(self, stats): + """ + Gather stats from all processes. Useful in the context of distributed training. + + Args: + stats (dict[str, Any]): + a dictionary of stats to be gathered. The stats should contain torch tensors. + + Returns: + `dict[str, Any]`: A dictionary of stats with the tensors gathered. + """ + import torch.distributed as dist + + # Wait for all processes to finish + dist.barrier() + + for k, v in stats.items(): + if isinstance(v, torch.Tensor): + dist.all_reduce(v.to(self.accelerator.device), dist.ReduceOp.SUM) + v /= self.accelerator.num_processes + stats[k] = v + return stats + + def prepare_model_inputs(self, queries: torch.Tensor, responses: torch.Tensor): + if self.is_encoder_decoder: + input_data = self.data_collator([{"input_ids": q, "attention_mask": torch.ones_like(q)} for q in queries]).to(self.current_device) + + decoder_inputs = self.data_collator([{"input_ids": r, "attention_mask": torch.ones_like(r)} for r in responses]).to(self.current_device) + + input_data["decoder_input_ids"] = decoder_inputs["input_ids"] + input_data["decoder_attention_mask"] = decoder_inputs["attention_mask"] + else: + input_ids = [torch.cat([q, r]) for q, r in zip(queries, responses)] + input_data = self.data_collator([{"input_ids": ids, "attention_mask": torch.ones_like(ids)} for ids in input_ids]).to(self.current_device) + + input_data.pop("labels", None) # we don't want to compute LM losses + return input_data + + @PPODecorators.empty_device_cache() + def batched_forward_pass( + self, + model: PreTrainedModelWrapper, + queries: torch.Tensor, + responses: torch.Tensor, + model_inputs: dict, + return_logits: bool = False, + response_masks: Optional[torch.Tensor] = None, + ): + """ + Calculate model outputs in multiple batches. + + Args: + queries (`torch.LongTensor`): + List of tensors containing the encoded queries, shape (`batch_size`, `query_length`) + responses (`torch.LongTensor`): + List of tensors containing the encoded responses, shape (`batch_size`, `response_length`) + return_logits (`bool`, *optional*, defaults to `False`): + Whether to return all_logits. Set to `False` if logits are not needed to reduce memory consumption. + Returns: + (tuple): + - all_logprobs (`torch.FloatTensor`): Log probabilities of the responses, + shape (`batch_size`, `response_length`) + - all_ref_logprobs (`torch.FloatTensor`): Log probabilities of the responses, + shape (`batch_size`, `response_length`) + - all_values (`torch.FloatTensor`): Values of the responses, shape (`batch_size`, `response_length`) + """ + bs = len(queries) + fbs = self.config.mini_batch_size + all_logprobs = [] + all_logits = [] + all_masks = [] + all_values = [] + + model.eval() + + for i in range(math.ceil(bs / fbs)): + input_kwargs = {key: value[i * fbs : (i + 1) * fbs] for key, value in model_inputs.items()} + query_batch = queries[i * fbs : (i + 1) * fbs] + response_batch = responses[i * fbs : (i + 1) * fbs] + if response_masks is not None: + response_masks_batch = response_masks[i * fbs : (i + 1) * fbs] + logits, _, values = model(**input_kwargs) + + if self.is_encoder_decoder: + input_ids = input_kwargs["decoder_input_ids"] + attention_mask = input_kwargs["decoder_attention_mask"] + else: + input_ids = input_kwargs["input_ids"] + attention_mask = input_kwargs["attention_mask"] + + logprobs = logprobs_from_logits(logits[:, :-1, :], input_ids[:, 1:]) + masks = torch.zeros_like(attention_mask) + masks[:, :-1] = attention_mask[:, 1:] + + for j in range(len(query_batch)): + if self.is_encoder_decoder: + # Decoder sentence starts always in the index 1 after padding in the Enc-Dec Models + start = 1 + end = attention_mask[j, :].sum() - 1 + else: + start = len(query_batch[j]) - 1 # logprobs starts from the second query token + if attention_mask[j, 0] == 0: # offset left padding + start += attention_mask[j, :].nonzero()[0] + end = start + len(response_batch[j]) + if response_masks is not None: + response_masks_batch[j] = torch.cat((torch.zeros_like(query_batch[j]), response_masks_batch[j]))[1:] + + masks[j, :start] = 0 + masks[j, end:] = 0 + if response_masks is not None: + masks[j, start:end] = masks[j, start:end] * response_masks_batch[j][start:end] + + if return_logits: + all_logits.append(logits) + else: + del logits + all_values.append(values) + all_logprobs.append(logprobs) + all_masks.append(masks) + + return ( + torch.cat(all_logprobs), + torch.cat(all_logits)[:, :-1] if return_logits else None, + torch.cat(all_values)[:, :-1], + torch.cat(all_masks)[:, :-1], + ) + + @PPODecorators.empty_device_cache() + def train_minibatch( + self, + old_logprobs: torch.FloatTensor, + values: torch.FloatTensor, + logprobs: torch.FloatTensor, + logits: torch.FloatTensor, + vpreds: torch.FloatTensor, + mask: torch.LongTensor, + advantages: torch.FloatTensor, + returns: torch.FloatTensor, + ): + """ + Train one PPO minibatch + + Args: + logprobs (`torch.FloatTensor`): + Log probabilities of the model, shape [mini_batch_size, response_length] + values (`torch.FloatTensor`): + Values of the value head, shape [mini_batch_size, response_length] + query (`torch.LongTensor`): + Encoded queries, shape [mini_batch_size, query_length] + response (`torch.LongTensor`): + Encoded responses, shape [mini_batch_size, response_length] + model_input (`torch.LongTensor`): + Concatenated queries and responses, shape [mini_batch_size, query_length+response_length] + + Returns: + train_stats (dict[str, `torch.Tensor`]): + Dictionary of training statistics + """ + self.model.train() + loss_p, loss_v, train_stats = self.loss(old_logprobs, values, logits, vpreds, logprobs, mask, advantages, returns) + loss = loss_p + loss_v + self.accelerator.backward(loss) + if self.config.max_grad_norm is not None: + if self.accelerator.sync_gradients: + self.accelerator.clip_grad_norm_(self.model_params, self.config.max_grad_norm) + self.optimizer.step() + # we call optimizer.zero_grad() every time and let `accelerator` handle accumulation + # see https://huggingface.co/docs/accelerate/usage_guides/gradient_accumulation#the-finished-code + self.optimizer.zero_grad() + return train_stats + + def compute_rewards( + self, + scores: torch.FloatTensor, + logprobs: torch.FloatTensor, + ref_logprobs: torch.FloatTensor, + masks: torch.LongTensor, + ): + """ + Compute per token rewards from scores and KL-penalty. + + Args: + scores (`torch.FloatTensor`): + Scores from the reward model, shape (`batch_size`) + logprobs (`torch.FloatTensor`): + Log probabilities of the model, shape (`batch_size`, `response_length`) + ref_logprobs (`torch.FloatTensor`): + Log probabilities of the reference model, shape (`batch_size`, `response_length`) + + Returns: + `torch.FloatTensor`: Per token rewards, shape (`batch_size`, `response_length`) + `torch.FloatTensor`: Non score rewards, shape (`batch_size`, `response_length`) + `torch.FloatTensor`: KL penalty, shape (`batch_size`, `response_length`) + """ + rewards, non_score_rewards, kls = [], [], [] + for score, logprob, ref_logprob, mask in zip(scores, logprobs, ref_logprobs, masks): + # compute KL penalty (from difference in logprobs) + kl = self._kl_penalty(logprob, ref_logprob) + kls.append(kl) + non_score_reward = -self.kl_ctl.value * kl + non_score_rewards.append(non_score_reward) + reward = non_score_reward.clone() + last_non_masked_index = mask.nonzero()[-1] + + # reward is preference model score + KL penalty + reward[last_non_masked_index] += score + rewards.append(reward) + return torch.stack(rewards), torch.stack(non_score_rewards), torch.stack(kls) + + def _kl_penalty(self, logprob: torch.FloatTensor, ref_logprob: torch.FloatTensor) -> torch.FloatTensor: + if self.config.kl_penalty == "kl": + return logprob - ref_logprob + + if self.config.kl_penalty == "abs": + return (logprob - ref_logprob).abs() + + if self.config.kl_penalty == "mse": + return 0.5 * (logprob - ref_logprob).square() + + if self.config.kl_penalty == "full": + # Flip is required due to this issue? :https://github.com/pytorch/pytorch/issues/57459 + return F.kl_div(ref_logprob, logprob, log_target=True, reduction="none").sum(-1) + + raise NotImplementedError + + def compute_advantages( + self, + values: torch.FloatTensor, + rewards: torch.FloatTensor, + mask: torch.FloatTensor, + ): + lastgaelam = 0 + advantages_reversed = [] + gen_len = rewards.shape[-1] + + values = values * mask + rewards = rewards * mask + + if self.config.whiten_rewards: + rewards = masked_whiten(rewards, mask, shift_mean=False) + + for t in reversed(range(gen_len)): + nextvalues = values[:, t + 1] if t < gen_len - 1 else 0.0 + delta = rewards[:, t] + self.config.gamma * nextvalues - values[:, t] + lastgaelam = delta + self.config.gamma * self.config.lam * lastgaelam + advantages_reversed.append(lastgaelam) + advantages = torch.stack(advantages_reversed[::-1]).transpose(0, 1) + + returns = advantages + values + advantages = masked_whiten(advantages, mask) + advantages = advantages.detach() + return values, advantages, returns + + def loss( + self, + old_logprobs: torch.FloatTensor, + values: torch.FloatTensor, + logits: torch.FloatTensor, + vpreds: torch.FloatTensor, + logprobs: torch.FloatTensor, + mask: torch.LongTensor, + advantages: torch.FloatTensor, + returns: torch.FloatTensor, + ): + """ + Calculate policy and value losses. + + Args: + old_logprobs (`torch.FloatTensor`): + Log probabilities of the model, shape (`batch_size`, `response_length`) + values (`torch.FloatTensor`): + Values of the value head, shape (`batch_size`, `response_length`) + rewards (`torch.FloatTensor`): + Rewards from the reward model, shape (`batch_size`, `response_length`) + logits (`torch.FloatTensor`): + Logits of the model, shape (`batch_size`, `response_length`, `vocab_size`) + v_pred (`torch.FloatTensor`): + Values of the value head, shape (`batch_size`, `response_length`) + logprobs (`torch.FloatTensor`): + Log probabilities of the model, shape (`batch_size`, `response_length`) + """ + + vpredclipped = clip_by_value( + vpreds, + values - self.config.cliprange_value, + values + self.config.cliprange_value, + ) + + vf_losses1 = (vpreds - returns) ** 2 + vf_losses2 = (vpredclipped - returns) ** 2 + vf_loss = 0.5 * masked_mean(torch.max(vf_losses1, vf_losses2), mask) + vf_clipfrac = masked_mean(torch.gt(vf_losses2, vf_losses1).float(), mask) + + ratio = torch.exp(logprobs - old_logprobs) + + pg_losses = -advantages * ratio + pg_losses2 = -advantages * torch.clamp(ratio, 1.0 - self.config.cliprange, 1.0 + self.config.cliprange) + + pg_loss = masked_mean(torch.max(pg_losses, pg_losses2), mask) + pg_clipfrac = masked_mean(torch.gt(pg_losses2, pg_losses).float(), mask) + + loss = pg_loss + self.config.vf_coef * vf_loss + + avg_ratio = masked_mean(ratio, mask).item() + if avg_ratio > self.config.ratio_threshold: + warnings.warn(f"The average ratio of batch ({avg_ratio:.2f}) exceeds threshold {self.config.ratio_threshold:.2f}. Skipping batch.") + pg_loss = pg_loss * 0.0 + vf_loss = vf_loss * 0.0 + loss = loss * 0.0 + + entropy = masked_mean(entropy_from_logits(logits), mask) + + approxkl = 0.5 * masked_mean((logprobs - old_logprobs) ** 2, mask) + policykl = masked_mean(old_logprobs - logprobs, mask) + + return_mean, return_var = masked_mean(returns, mask), masked_var(returns, mask) + value_mean, value_var = masked_mean(values, mask), masked_var(values, mask) + + stats = dict( + loss=dict(policy=pg_loss.detach(), value=vf_loss.detach(), total=loss.detach()), + policy=dict( + entropy=entropy.detach(), + approxkl=approxkl.detach(), + policykl=policykl.detach(), + clipfrac=pg_clipfrac.detach(), + advantages=advantages.detach(), + advantages_mean=masked_mean(advantages, mask).detach(), + ratio=ratio.detach(), + ), + returns=dict(mean=return_mean.detach(), var=return_var.detach()), + val=dict( + vpred=masked_mean(vpreds, mask).detach(), + error=masked_mean((vpreds - returns) ** 2, mask).detach(), + clipfrac=vf_clipfrac.detach(), + mean=value_mean.detach(), + var=value_var.detach(), + ), + ) + return pg_loss, self.config.vf_coef * vf_loss, flatten_dict(stats) + + def record_step_stats(self, kl_coef: float, **data): + """ + Record training step statistics. + + + Args: + kl_coef (`float`): + KL coefficient + data (`dict`): + Dictionary of training step data + + Returns: + stats (`dict`): + Dictionary of training step statistics + """ + mask = data.pop("masks") + + kls = data.pop("kls") + kl_list = ((kls) * mask).sum(axis=-1) + mean_kl = kl_list.mean() + mean_entropy = (-data["logprobs"] * mask).sum(axis=-1).mean() + + mean_non_score_reward = masked_mean(data["non_score_reward"], mask) # non_score_reward is size `batch_size`, `response_length` + mean_scores = data["scores"].mean() # scores is size `batch_size` + std_scores = data["scores"].std() + + if mean_kl.item() < -1.0: + # warn users + warnings.warn( + f"KL divergence is starting to become negative: {mean_kl.item():.2f} - this might be a precursor for failed training." + " sometimes this happens because the generation kwargs are not correctly set. Please make sure" + " that the generation kwargs are set correctly, or review your training hyperparameters." + ) + + stats = { + "objective/kl": mean_kl, + "objective/kl_dist": kl_list, + "objective/logprobs": data["logprobs"], + "objective/ref_logprobs": data["ref_logprobs"], + "objective/kl_coef": kl_coef, + "objective/entropy": mean_entropy, + "ppo/mean_non_score_reward": mean_non_score_reward, + "ppo/mean_scores": mean_scores, + "ppo/std_scores": std_scores, + } + + # Log text properties + query_lens = torch.tensor([len(query) for query in data["queries"]], dtype=torch.float) + response_lens = torch.tensor([len(response) for response in data["responses"]], dtype=torch.float) + + stats["tokens/queries_len_mean"] = torch.mean(query_lens).cpu().numpy().item() + stats["tokens/queries_len_std"] = torch.std(query_lens).cpu().numpy().item() + stats["tokens/queries_dist"] = query_lens.cpu().numpy() + stats["tokens/responses_len_mean"] = torch.mean(response_lens).cpu().numpy().item() + stats["tokens/responses_len_std"] = torch.std(response_lens).cpu().numpy().item() + stats["tokens/responses_dist"] = response_lens.cpu().numpy() + + for k, v in data["train_stats"].items(): + stats[f"ppo/{k}"] = torch.mean(v, axis=0) + stats["ppo/val/var_explained"] = 1 - stats["ppo/val/error"] / stats["ppo/returns/var"] + return stats + + def log_stats( + self, + stats: dict, + batch: dict, + rewards: List[torch.FloatTensor], + columns_to_log: List[str] = ["query", "response"], + ): + """ + A function that logs all the training stats. Call it at the end of each epoch. + + Args: + stats (dict[str, Any]): + A dictionary of training stats. + batch (dict[str, Any]): + A dictionary of batch data, this contains the queries and responses. + rewards (`List[torch.FloatTensor]`): + A tensor of rewards. + """ + + # all gather stats + if not isinstance(rewards, torch.Tensor): + rewards = torch.tensor(rewards).to(self.current_device) + rewards = self.accelerator.gather(rewards).flatten() + + if self.config.log_with == "wandb": + import wandb + + if any([column_to_log not in batch.keys() for column_to_log in columns_to_log]): + raise ValueError(f"Columns to log {columns_to_log} are not present in the batch {batch.keys()}.") + + batch_list = [batch[column_to_log] for column_to_log in columns_to_log] + if self.is_distributed: + gathered_batch_list = [] + for b in batch_list: + flattened = gather_object(b) + gathered_batch_list.append(flattened) + batch_list = gathered_batch_list + + # Log only if we are in the main process + if self.accelerator.is_main_process: + logs = {} + + # Log stats + if "query" not in batch.keys() and "response" not in batch.keys(): + # warn the user that the game logs will not be logged + warnings.warn("The game logs will not be logged because the batch does not contain the keys 'query' and " "'response'. ") + elif self.config.log_with == "wandb": + table_rows = [list(r) for r in zip(*batch_list, rewards.cpu().tolist())] + logs.update({"game_log": wandb.Table(columns=[*columns_to_log, "reward"], rows=table_rows)}) + + logs.update(stats) + + # manually cast in fp32 for bf16 torch tensors + for k, v in logs.items(): + if isinstance(v, torch.Tensor) and v.dtype == torch.bfloat16: + logs[k] = v.float() + + logs["env/reward_mean"] = torch.mean(rewards).cpu().numpy().item() + logs["env/reward_std"] = torch.std(rewards).cpu().numpy().item() + logs["env/reward_dist"] = rewards.cpu().numpy() + + if self.config.log_with == "tensorboard": + # update the current step + self.current_step += 1 + + self.accelerator.log( + logs, + step=self.current_step if self.config.log_with == "tensorboard" else None, + ) + + def create_model_card(self, path: str, model_name: Optional[str] = "TRL Model") -> None: + """Creates and saves a model card for a TRL model. + + Args: + path (`str`): The path to save the model card to. + model_name (`str`, *optional*): The name of the model, defaults to `TRL Model`. + """ + try: + user = whoami()["name"] + # handle the offline case + except: # noqa + warnings.warn("Cannot retrieve user information assuming you are running in offline mode.") + return + + if not os.path.exists(path): + os.makedirs(path) + + model_card_content = MODEL_CARD_TEMPLATE.format(model_name=model_name, model_id=f"{user}/{path}") + with open(os.path.join(path, "README.md"), "w", encoding="utf-8") as f: + f.write(model_card_content) + + def _save_pretrained(self, save_directory: str) -> None: + self.accelerator.unwrap_model(self.model).save_pretrained(save_directory) + self.tokenizer.save_pretrained(save_directory) + self.create_model_card(save_directory) + + def _show_tokens(self, tokens, masks): + from rich import print + from rich.text import Text + + text = Text() + + for i, (token, mask) in enumerate(zip(tokens, masks)): + if mask == 1: + text.append(self.tokenizer.decode(token.item()), style="black on deep_sky_blue1") + text.append(" ") + else: + text.append(self.tokenizer.decode(token.item()), style="black on cyan3") + text.append(" ") + print(text) + + def _prepare_deepspeed(self, model: PreTrainedModelWrapper): + # Adapted from accelerate: https://github.com/huggingface/accelerate/blob/739b135f8367becb67ffaada12fe76e3aa60fefd/src/accelerate/accelerator.py#L1473 + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + config_kwargs = deepspeed_plugin.deepspeed_config + if model is not None: + if hasattr(model, "config"): + hidden_size = max(model.config.hidden_sizes) if getattr(model.config, "hidden_sizes", None) else getattr(model.config, "hidden_size", None) + if hidden_size is not None and config_kwargs["zero_optimization"]["stage"] == 3: + # Note that `stage3_prefetch_bucket_size` can produce DeepSpeed messages like: `Invalidate trace cache @ step 0: expected module 1, but got module 0` + # This is expected and is not an error, see: https://github.com/microsoft/DeepSpeed/discussions/4081 + config_kwargs.update( + { + "zero_optimization.reduce_bucket_size": hidden_size * hidden_size, + "zero_optimization.stage3_param_persistence_threshold": 10 * hidden_size, + "zero_optimization.stage3_prefetch_bucket_size": 0.9 * hidden_size * hidden_size, + } + ) + + # If ZeRO-3 is used, we shard both the active and reference model. + # Otherwise, we assume the reference model fits in memory and is initialized on each device with ZeRO disabled (stage 0) + if config_kwargs["zero_optimization"]["stage"] != 3: + config_kwargs["zero_optimization"]["stage"] = 0 + model, *_ = deepspeed.initialize(model=model, config=config_kwargs) + model.eval() + return model diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/reward_config.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/reward_config.py new file mode 100644 index 0000000000000000000000000000000000000000..32c7e264d1fe84e6ea229ec404465d9aba9b391c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/reward_config.py @@ -0,0 +1,38 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from dataclasses import dataclass +from typing import Optional + +from transformers import TrainingArguments + + +@dataclass +class RewardConfig(TrainingArguments): + """ + RewardConfig collects all training arguments related to the [`RewardTrainer`] class. + + Using [`HfArgumentParser`] we can turn this class into + [argparse](https://docs.python.org/3/library/argparse#module-argparse) arguments that can be specified on the + command line. + + Parameters: + max_length (`int`, *optional*, defaults to `None`): + The maximum length of the sequences in the batch. This argument is required if you want to use the default data collator. + gradient_checkpointing (`bool`, *optional*, defaults to `True`): + If True, use gradient checkpointing to save memory at the expense of slower backward pass. + """ + + max_length: Optional[int] = None + """The maximum length of the sequences in the batch. This argument is required if you want to use the default data collator.""" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/reward_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/reward_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..eff4eb7abe44f777c13443dcf76e74cd339c9527 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/reward_trainer.py @@ -0,0 +1,257 @@ +# Copyright 2023 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import inspect +import warnings +from dataclasses import FrozenInstanceError, replace +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +import torch +import torch.nn as nn +from datasets import Dataset +from transformers import DataCollator, PreTrainedModel, PreTrainedTokenizerBase, Trainer, TrainingArguments +from transformers.trainer_callback import TrainerCallback +from transformers.trainer_pt_utils import nested_detach +from transformers.trainer_utils import EvalPrediction + +from ..import_utils import is_peft_available +from .reward_config import RewardConfig +from .utils import RewardDataCollatorWithPadding, compute_accuracy + + +if is_peft_available(): + from peft import PeftModel, get_peft_model, prepare_model_for_kbit_training + + +class RewardTrainer(Trainer): + r""" + The RewardTrainer can be used to train your custom Reward Model. It is a subclass of the + `transformers.Trainer` class and inherits all of its attributes and methods. It is recommended to use + an `AutoModelForSequenceClassification` as the reward model. The reward model should be trained on a dataset + of paired examples, where each example is a tuple of two sequences. The reward model should be trained to + predict which example in the pair is more relevant to the task at hand. + + The reward trainer expects a very specific format for the dataset. The dataset should contain two 4 entries at least + if you don't use the default `RewardDataCollatorWithPadding` data collator. The entries should be named + - `input_ids_chosen` + - `attention_mask_chosen` + - `input_ids_rejected` + - `attention_mask_rejected` + + Optionally, you can also pass a `margin` entry to the dataset. This entry should contain the margin used to modulate the + loss of the reward model as outlined in https://ai.meta.com/research/publications/llama-2-open-foundation-and-fine-tuned-chat-models/. + If you don't pass a margin, no margin will be used. + """ + + def __init__( + self, + model: Union[PreTrainedModel, nn.Module] = None, + args: Optional[RewardConfig] = None, + data_collator: Optional[DataCollator] = None, + train_dataset: Optional[Dataset] = None, + eval_dataset: Optional[Union[Dataset, Dict[str, Dataset]]] = None, + tokenizer: Optional[PreTrainedTokenizerBase] = None, + model_init: Optional[Callable[[], PreTrainedModel]] = None, + compute_metrics: Optional[Callable[[EvalPrediction], Dict]] = None, + callbacks: Optional[List[TrainerCallback]] = None, + optimizers: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = ( + None, + None, + ), + preprocess_logits_for_metrics: Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None, + max_length: Optional[int] = None, + peft_config: Optional[Dict] = None, + ): + """ + Initialize RewardTrainer. + + Args: + model (`transformers.PreTrainedModel`): + The model to train, preferably an `AutoModelForSequenceClassification`. + args (`RewardConfig`): + The arguments to use for training. + data_collator (`transformers.DataCollator`): + The data collator to use for training. If None is specified, the default data collator (`RewardDataCollatorWithPadding`) will be used + which will pad the sequences to the maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset (`datasets.Dataset`): + The dataset to use for training. + eval_dataset (`datasets.Dataset`): + The dataset to use for evaluation. + tokenizer (`transformers.PreTrainedTokenizerBase`): + The tokenizer to use for training. This argument is required if you want to use the default data collator. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be used. + compute_metrics (`Callable[[transformers.EvalPrediction], Dict]`, *optional* defaults to `compute_accuracy`): + The metrics to use for evaluation. If no metrics are specified, the default metric (`compute_accuracy`) will be used. + callbacks (`List[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + max_length (`int`, defaults to `None`): + The maximum length of the sequences in the batch. This argument is required if you want to use the default data collator. + peft_config (`Dict`, defaults to `None`): + The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in a PEFT model. + """ + if type(args) == TrainingArguments: + warnings.warn( + "Using `transformers.TrainingArguments` for `args` is deprecated and will be removed in a future version. Please use `RewardConfig` instead.", + FutureWarning, + ) + if max_length is not None: + warnings.warn( + "The `max_length` argument is deprecated and will be removed in a future version. Please use the `RewardConfig` to set `max_length` instead.", + FutureWarning, + ) + else: + if max_length is not None and args.max_length is not None: + raise ValueError("You cannot specify both `max_length` and `args.max_length`. Please use the `RewardConfig` to set `max_length` once.") + if max_length is not None and args.max_length is None: + warnings.warn( + "The `max_length` argument is deprecated and will be removed in a future version. Please use the `RewardConfig` to set `max_length` instead.", + FutureWarning, + ) + if not is_peft_available() and peft_config is not None: + raise ValueError("PEFT is not installed and you passed a `peft_config` in the trainer's kwargs, please install it to use the PEFT models") + elif is_peft_available() and peft_config is not None: + if not isinstance(model, PeftModel): + if getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_quantized", False): + _supports_gc_kwargs = "gradient_checkpointing_kwargs" in list(inspect.signature(prepare_model_for_kbit_training).parameters) + + preprare_model_kwargs = {"use_gradient_checkpointing": args.gradient_checkpointing} + + if not _supports_gc_kwargs and args.gradient_checkpointing_kwargs is not None: + warnings.warn("You passed `gradient_checkpointing_kwargs` in the trainer's kwargs, but your peft version does not support it. " "please update to the latest version of peft to use `gradient_checkpointing_kwargs`.") + elif _supports_gc_kwargs and args.gradient_checkpointing_kwargs is not None: + preprare_model_kwargs["gradient_checkpointing_kwargs"] = args.gradient_checkpointing_kwargs + + model = prepare_model_for_kbit_training(model, **preprare_model_kwargs) + + model = get_peft_model(model, peft_config) + + if compute_metrics is None: + compute_metrics = compute_accuracy + + if data_collator is None: + if tokenizer is None: + raise ValueError("max_length or a tokenizer must be specified when using the default RewardDataCollatorWithPadding") + if type(args) == TrainingArguments: + if max_length is None: + warnings.warn( + "When using RewardDataCollatorWithPadding, you should set `max_length` in RewardConfig." " It will be set to `512` by default, but you should do it yourself in the future.", + UserWarning, + ) + max_length = 512 + else: + if max_length is None and args.max_length is None: + warnings.warn( + "When using RewardDataCollatorWithPadding, you should set `max_length` in RewardConfig." " It will be set to `512` by default, but you should do it yourself in the future.", + UserWarning, + ) + max_length = 512 + if max_length is None and args.max_length is not None: + max_length = args.max_length + + data_collator = RewardDataCollatorWithPadding(tokenizer, max_length=max_length) + + if args.remove_unused_columns: + try: # for bc before https://github.com/huggingface/transformers/pull/25435 + args.remove_unused_columns = False + except FrozenInstanceError: + args = replace(args, remove_unused_columns=False) + # warn users + warnings.warn( + "When using RewardDataCollatorWithPadding, you should set `remove_unused_columns=False` in your RewardConfig" " we have set it for you, but you should do it yourself in the future.", + UserWarning, + ) + + self.use_reward_data_collator = True + else: + self.use_reward_data_collator = False + super().__init__( + model, + args, + data_collator, + train_dataset, + eval_dataset, + tokenizer, + model_init, + compute_metrics, + callbacks, + optimizers, + preprocess_logits_for_metrics, + ) + + def compute_loss( + self, + model: Union[PreTrainedModel, nn.Module], + inputs: Dict[str, Union[torch.Tensor, Any]], + return_outputs=False, + ) -> Union[torch.Tensor, Tuple[torch.Tensor, Dict[str, torch.Tensor]]]: + if not self.use_reward_data_collator: + warnings.warn("The current compute_loss is implemented for RewardDataCollatorWithPadding," " if you are using a custom data collator make sure you know what you are doing or" " implement your own compute_loss method.") + rewards_chosen = model( + input_ids=inputs["input_ids_chosen"], + attention_mask=inputs["attention_mask_chosen"], + return_dict=True, + )["logits"] + rewards_rejected = model( + input_ids=inputs["input_ids_rejected"], + attention_mask=inputs["attention_mask_rejected"], + return_dict=True, + )["logits"] + # calculate loss, optionally modulate with margin + if "margin" in inputs: + loss = -nn.functional.logsigmoid(rewards_chosen - rewards_rejected - inputs["margin"]).mean() + else: + loss = -nn.functional.logsigmoid(rewards_chosen - rewards_rejected).mean() + + if return_outputs: + return loss, { + "rewards_chosen": rewards_chosen, + "rewards_rejected": rewards_rejected, + } + return loss + + def prediction_step( + self, + model: Union[PreTrainedModel, nn.Module], + inputs: Dict[str, Union[torch.Tensor, Any]], + prediction_loss_only: bool, + ignore_keys: Optional[List[str]] = None, + ) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]: + inputs = self._prepare_inputs(inputs) + if ignore_keys is None: + if hasattr(self.model, "config"): + ignore_keys = getattr(self.model.config, "keys_to_ignore_at_inference", []) + else: + ignore_keys = [] + + with torch.no_grad(): + loss, logits_dict = self.compute_loss(model, inputs, return_outputs=True) + + if prediction_loss_only: + return (loss, None, None) + + loss = loss.detach() + logits = tuple(v for k, v in logits_dict.items() if k not in ignore_keys) + logits = nested_detach(logits) + # Stack accepted against rejected, mean over logits + # and softmax to get preferences between accepted and rejected to sum to 1 + logits = torch.stack(logits).mean(dim=2).softmax(dim=0).T + + labels = torch.zeros(logits.shape[0]) + labels = self._prepare_inputs(labels) + + return loss, logits, labels diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/sft_trainer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/sft_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..69f32750b877088aa58b447db4ba1b2fa8c8d1d8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/sft_trainer.py @@ -0,0 +1,480 @@ +# Copyright 2023 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import dataclasses +import inspect +import warnings +from functools import wraps +from typing import Callable, Dict, List, Optional, Tuple, Union + +import torch +import torch.nn as nn +from accelerate.state import PartialState +from datasets import Dataset +from datasets.arrow_writer import SchemaInferenceError +from datasets.builder import DatasetGenerationError +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollator, + DataCollatorForLanguageModeling, + PreTrainedModel, + PreTrainedTokenizerBase, + Trainer, + TrainingArguments, +) +from transformers.modeling_utils import unwrap_model +from transformers.trainer_callback import TrainerCallback +from transformers.trainer_utils import EvalPrediction + +from ..extras.dataset_formatting import get_formatting_func_from_dataset +from ..import_utils import is_peft_available +from .utils import ( + ConstantLengthDataset, + DataCollatorForCompletionOnlyLM, + neftune_post_forward_hook, + peft_module_casting_to_bf16, + trl_sanitze_kwargs_for_tagging, +) + + +if is_peft_available(): + from peft import PeftConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training + + +class SFTTrainer(Trainer): + r""" + Class definition of the Supervised Finetuning Trainer (SFT Trainer). + This class is a wrapper around the `transformers.Trainer` class and inherits all of its attributes and methods. + The trainer takes care of properly initializing the PeftModel in case a user passes a `PeftConfig` object. + + Args: + model (Union[`transformers.PreTrainedModel`, `nn.Module`, `str`]): + The model to train, can be a `PreTrainedModel`, a `torch.nn.Module` or a string with the model name to + load from cache or download. The model can be also converted to a `PeftModel` if a `PeftConfig` object is + passed to the `peft_config` argument. + args (Optional[`transformers.TrainingArguments`]): + The arguments to tweak for training. Please refer to the official documentation of `transformers.TrainingArguments` + for more information. + data_collator (Optional[`transformers.DataCollator`]): + The data collator to use for training. + train_dataset (Optional[`datasets.Dataset`]): + The dataset to use for training. We recommend users to use `trl.trainer.ConstantLengthDataset` to create their dataset. + eval_dataset (Optional[Union[`datasets.Dataset`, Dict[`str`, `datasets.Dataset`]]]): + The dataset to use for evaluation. We recommend users to use `trl.trainer.ConstantLengthDataset` to create their dataset. + tokenizer (Optional[`transformers.PreTrainedTokenizer`]): + The tokenizer to use for training. If not specified, the tokenizer associated to the model will be used. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be used. + compute_metrics (`Callable[[transformers.EvalPrediction], Dict]`, *optional* defaults to None): + The function used to compute metrics during evaluation. It should return a dictionary mapping metric names to metric values. + If not specified, only the loss will be computed during evaluation. + callbacks (`List[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + peft_config (`Optional[PeftConfig]`): + The PeftConfig object to use to initialize the PeftModel. + dataset_text_field (`Optional[str]`): + The name of the text field of the dataset, in case this is passed by a user, the trainer will automatically create a + `ConstantLengthDataset` based on the `dataset_text_field` argument. + formatting_func (`Optional[Callable]`): + The formatting function to be used for creating the `ConstantLengthDataset`. + max_seq_length (`Optional[int]`): + The maximum sequence length to use for the `ConstantLengthDataset` and for automatically creating the Dataset. Defaults to `512`. + infinite (`Optional[bool]`): + Whether to use an infinite dataset or not. Defaults to `False`. + num_of_sequences (`Optional[int]`): + The number of sequences to use for the `ConstantLengthDataset`. Defaults to `1024`. + chars_per_token (`Optional[float]`): + The number of characters per token to use for the `ConstantLengthDataset`. Defaults to `3.6`. You can check how this is computed in the + stack-llama example: https://github.com/huggingface/trl/blob/08f550674c553c36c51d1027613c29f14f3676a5/examples/stack_llama/scripts/supervised_finetuning.py#L53. + packing (`Optional[bool]`): + Used only in case `dataset_text_field` is passed. This argument is used by the `ConstantLengthDataset` to pack the sequences + of the dataset. + dataset_num_proc (`Optional[int]`): + The number of workers to use to tokenize the data. Only used when `packing=False`. Defaults to None. + dataset_batch_size (`int`): + The number of examples to tokenize per batch. If batch_size <= 0 or batch_size == None, + tokenize the full dataset as a single batch. Defaults to 1000. + neftune_noise_alpha (`Optional[float]`): + If not `None`, this will activate NEFTune noise embeddings. This has been proven to drastically improve model performances for instruction + fine-tuning. Check out the original paper here: https://arxiv.org/abs/2310.05914 and the original code here: https://github.com/neelsjain/NEFTune + model_init_kwargs: (`Optional[Dict]`, *optional*): + Dict of Optional kwargs to pass when instantiating the model from a string + dataset_kwargs: (`Optional[Dict]`, *optional*): + Dict of Optional kwargs to pass when creating packed or non-packed datasets + """ + + _tag_names = ["trl", "sft"] + + def __init__( + self, + model: Union[PreTrainedModel, nn.Module, str] = None, + args: TrainingArguments = None, + data_collator: Optional[DataCollator] = None, + train_dataset: Optional[Dataset] = None, + eval_dataset: Optional[Union[Dataset, Dict[str, Dataset]]] = None, + tokenizer: Optional[PreTrainedTokenizerBase] = None, + model_init: Optional[Callable[[], PreTrainedModel]] = None, + compute_metrics: Optional[Callable[[EvalPrediction], Dict]] = None, + callbacks: Optional[List[TrainerCallback]] = None, + optimizers: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None, + peft_config: Optional["PeftConfig"] = None, + dataset_text_field: Optional[str] = None, + packing: Optional[bool] = False, + formatting_func: Optional[Callable] = None, + max_seq_length: Optional[int] = None, + infinite: Optional[bool] = None, + num_of_sequences: Optional[int] = 1024, + chars_per_token: Optional[float] = 3.6, + dataset_num_proc: Optional[int] = None, + dataset_batch_size: int = 1000, + neftune_noise_alpha: Optional[float] = None, + model_init_kwargs: Optional[Dict] = None, + dataset_kwargs: Optional[Dict] = None, + ): + if model_init_kwargs is None: + model_init_kwargs = {} + elif not isinstance(model, str): + raise ValueError("You passed model_kwargs to the SFTTrainer. But your model is already instantiated.") + + if infinite is not None: + warnings.warn("The `infinite` argument is deprecated and will be removed in a future version of TRL. Use `TrainingArguments.max_steps` or `TrainingArguments.num_train_epochs` instead to control training length.") + + if isinstance(model, str): + warnings.warn("You passed a model_id to the SFTTrainer. This will automatically create an " "`AutoModelForCausalLM` or a `PeftModel` (if you passed a `peft_config`) for you.") + model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs) + + if packing and data_collator is not None and isinstance(data_collator, DataCollatorForCompletionOnlyLM): + raise ValueError("You passed a `DataCollatorForCompletionOnlyLM` to the SFTTrainer. This is not compatible with the `packing` argument.") + + if is_peft_available() and peft_config is not None: + if not isinstance(peft_config, PeftConfig): + raise ValueError("If you want to use the PeftModel, you need to pass a PeftConfig object to the SFTTrainer." f" and you passed a {type(peft_config)}.") + + if not isinstance(model, PeftModel): + _support_gc_kwargs = hasattr(args, "gradient_checkpointing_kwargs") and "gradient_checkpointing_kwargs" in list(inspect.signature(prepare_model_for_kbit_training).parameters) + gradient_checkpointing_kwargs = getattr(args, "gradient_checkpointing_kwargs", None) or {} + if getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False): + preprare_model_kwargs = {"use_gradient_checkpointing": getattr(args, "gradient_checkpointing", False)} + + if _support_gc_kwargs: + preprare_model_kwargs["gradient_checkpointing_kwargs"] = gradient_checkpointing_kwargs + + model = prepare_model_for_kbit_training(model, **preprare_model_kwargs) + + if args is not None: + args = dataclasses.replace(args, gradient_checkpointing=False) + elif getattr(args, "gradient_checkpointing", False) and ("use_reentrant" not in gradient_checkpointing_kwargs or gradient_checkpointing_kwargs["use_reentrant"]): + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + model = get_peft_model(model, peft_config) + if args.bf16 and getattr(model, "is_loaded_in_4bit", False): + peft_module_casting_to_bf16(model) + + if tokenizer is None: + tokenizer = AutoTokenizer.from_pretrained(model.config._name_or_path) + if getattr(tokenizer, "pad_token", None) is None: + tokenizer.pad_token = tokenizer.eos_token + + if max_seq_length is None: + # to overcome some issues with broken tokenizers + max_seq_length = min(tokenizer.model_max_length, 1024) + + warnings.warn(f"You didn't pass a `max_seq_length` argument to the SFTTrainer, this will default to {max_seq_length}") + + self.dataset_num_proc = dataset_num_proc + self.dataset_batch_size = dataset_batch_size + + self._trainer_supports_neftune = hasattr(args, "neftune_noise_alpha") + + if neftune_noise_alpha is not None and self._trainer_supports_neftune: + args.neftune_noise_alpha = neftune_noise_alpha + warnings.warn("You passed a `neftune_noise_alpha` argument to the SFTTrainer, the value you passed will override the one in the `TrainingArguments`.") + # self.neftune_noise_alpha is done at Trainer level + elif not self._trainer_supports_neftune: + self.neftune_noise_alpha = neftune_noise_alpha + + if formatting_func is None and dataset_text_field is None: + # check if dataset has ChatML format or instruction format and is supported + # if not stays #None + formatting_func = get_formatting_func_from_dataset(train_dataset, tokenizer) + + if not packing: + if dataset_text_field is None and formatting_func is None: + raise ValueError("You passed `packing=False` to the SFTTrainer, but you didn't pass a `dataset_text_field` or `formatting_func` argument.") + + if data_collator is None: + data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False) + + # Pre-process the datasets only once per node. The remaining processes will use the cache. + with PartialState().local_main_process_first(): + if dataset_kwargs is None: + dataset_kwargs = {} + if train_dataset is not None: + train_dataset = self._prepare_dataset( + train_dataset, + tokenizer, + packing, + dataset_text_field, + max_seq_length, + formatting_func, + num_of_sequences, + chars_per_token, + remove_unused_columns=args.remove_unused_columns if args is not None else True, + **dataset_kwargs, + ) + if eval_dataset is not None: + _multiple = isinstance(eval_dataset, dict) + _eval_datasets = eval_dataset if _multiple else {"singleton": eval_dataset} + for _eval_dataset_name, _eval_dataset in _eval_datasets.items(): + _eval_datasets[_eval_dataset_name] = self._prepare_dataset( + _eval_dataset, + tokenizer, + packing, + dataset_text_field, + max_seq_length, + formatting_func, + num_of_sequences, + chars_per_token, + remove_unused_columns=args.remove_unused_columns if args is not None else True, + **dataset_kwargs, + ) + if not _multiple: + eval_dataset = _eval_datasets["singleton"] + + if tokenizer.padding_side is not None and tokenizer.padding_side != "right": + warnings.warn( + "You passed a tokenizer with `padding_side` not equal to `right` to the SFTTrainer. This might lead to some unexpected behaviour due to " + "overflow issues when training a model in half-precision. You might consider adding `tokenizer.padding_side = 'right'` to your code." + ) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + tokenizer=tokenizer, + model_init=model_init, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + if self.args.max_steps > 0 and packing: + warnings.warn("You passed `packing=True` to the SFTTrainer, and you are training your model with `max_steps` strategy. The dataset will be iterated until the `max_steps` are reached.") + self.train_dataset.infinite = True + elif self.args.max_steps == -1 and packing: + self.train_dataset.infinite = False + + @wraps(Trainer.train) + def train(self, *args, **kwargs): + # Activate neftune right before training. + if self.neftune_noise_alpha is not None and not self._trainer_supports_neftune: + self.model = self._trl_activate_neftune(self.model) + + output = super().train(*args, **kwargs) + + # After training we make sure to retrieve back the original forward pass method + # for the embedding layer by removing the forward post hook. + if self.neftune_noise_alpha is not None and not self._trainer_supports_neftune: + unwrapped_model = unwrap_model(self.model) + if is_peft_available() and isinstance(unwrapped_model, PeftModel): + embeddings = unwrapped_model.base_model.model.get_input_embeddings() + else: + embeddings = unwrapped_model.get_input_embeddings() + + self.neftune_hook_handle.remove() + del embeddings.neftune_noise_alpha + + return output + + @wraps(Trainer.push_to_hub) + def push_to_hub(self, commit_message: Optional[str] = "End of training", blocking: bool = True, **kwargs) -> str: + """ + Overwrite the `push_to_hub` method in order to force-add the tag "sft" when pushing the + model on the Hub. Please refer to `~transformers.Trainer.push_to_hub` for more details. + """ + kwargs = trl_sanitze_kwargs_for_tagging(model=self.model, tag_names=self._tag_names, kwargs=kwargs) + + return super().push_to_hub(commit_message=commit_message, blocking=blocking, **kwargs) + + def _prepare_dataset( + self, + dataset, + tokenizer, + packing, + dataset_text_field, + max_seq_length, + formatting_func, + num_of_sequences, + chars_per_token, + remove_unused_columns=True, + append_concat_token=True, + add_special_tokens=True, + ): + if dataset is None: + raise ValueError("The dataset should not be None") + + # check if torch dataset / dataloader and do nothing + if isinstance(dataset, (torch.utils.data.IterableDataset, torch.utils.data.Dataset, ConstantLengthDataset)): + return dataset + + if not packing: + return self._prepare_non_packed_dataloader( + tokenizer, + dataset, + dataset_text_field, + max_seq_length, + formatting_func, + add_special_tokens, + remove_unused_columns, + ) + + else: + return self._prepare_packed_dataloader( + tokenizer, + dataset, + dataset_text_field, + max_seq_length, + num_of_sequences, + chars_per_token, + formatting_func, + append_concat_token, + add_special_tokens, + ) + + def _prepare_non_packed_dataloader( + self, + tokenizer, + dataset, + dataset_text_field, + max_seq_length, + formatting_func=None, + add_special_tokens=True, + remove_unused_columns=True, + ): + use_formatting_func = formatting_func is not None and dataset_text_field is None + self._dataset_sanity_checked = False + + # Inspired from: https://huggingface.co/learn/nlp-course/chapter7/6?fw=pt + def tokenize(element): + outputs = tokenizer( + element[dataset_text_field] if not use_formatting_func else formatting_func(element), + add_special_tokens=add_special_tokens, + truncation=True, + padding=False, + max_length=max_seq_length, + return_overflowing_tokens=False, + return_length=False, + ) + + if use_formatting_func and not self._dataset_sanity_checked: + if not isinstance(formatting_func(element), list): + raise ValueError("The `formatting_func` should return a list of processed strings since it can lead to silent bugs.") + else: + self._dataset_sanity_checked = True + + return {"input_ids": outputs["input_ids"], "attention_mask": outputs["attention_mask"]} + + signature_columns = ["input_ids", "labels", "attention_mask"] + + extra_columns = list(set(dataset.column_names) - set(signature_columns)) + + if not remove_unused_columns and len(extra_columns) > 0: + warnings.warn( + "You passed `remove_unused_columns=False` on a non-packed dataset. This might create some issues with the default collator and yield to errors. If you want to " + f"inspect dataset other columns (in this case {extra_columns}), you can subclass `DataCollatorForLanguageModeling` in case you used the default collator and create your own data collator in order to inspect the unused dataset columns." + ) + + tokenized_dataset = dataset.map( + tokenize, + batched=True, + remove_columns=dataset.column_names if remove_unused_columns else None, + num_proc=self.dataset_num_proc, + batch_size=self.dataset_batch_size, + ) + + return tokenized_dataset + + def _prepare_packed_dataloader( + self, + tokenizer, + dataset, + dataset_text_field, + max_seq_length, + num_of_sequences, + chars_per_token, + formatting_func=None, + append_concat_token=True, + add_special_tokens=True, + ): + if dataset_text_field is not None or formatting_func is not None: + if tokenizer is None: + raise ValueError("You need to pass a tokenizer when using `dataset_text_field` with `SFTTrainer`.") + + constant_length_iterator = ConstantLengthDataset( + tokenizer, + dataset, + dataset_text_field=dataset_text_field, + formatting_func=formatting_func, + seq_length=max_seq_length, + infinite=False, + num_of_sequences=num_of_sequences, + chars_per_token=chars_per_token, + eos_token_id=tokenizer.eos_token_id, + append_concat_token=append_concat_token, + add_special_tokens=add_special_tokens, + ) + + def data_generator(constant_length_iterator): + for i in constant_length_iterator: + yield i + + try: + packed_dataset = Dataset.from_generator(data_generator, gen_kwargs={"constant_length_iterator": constant_length_iterator}) + except (DatasetGenerationError, SchemaInferenceError): + raise ValueError("Error occurred while packing the dataset. Make sure that your dataset has enough samples to at least yield one packed sequence.") + return packed_dataset + else: + raise ValueError("You need to pass a `dataset_text_field` or `formatting_func` argument to the SFTTrainer if you want to use the `ConstantLengthDataset`.") + + def _trl_activate_neftune(self, model): + r""" + Activates the neftune as presented in this code: https://github.com/neelsjain/NEFTune and paper: https://arxiv.org/abs/2310.05914 + Since in transformers Trainer we do have an `_activate_neftune` method, we need to rename this method to avoid conflicts. + """ + unwrapped_model = unwrap_model(model) + if is_peft_available() and isinstance(unwrapped_model, PeftModel): + embeddings = unwrapped_model.base_model.model.get_input_embeddings() + else: + embeddings = unwrapped_model.get_input_embeddings() + + embeddings.neftune_noise_alpha = self.neftune_noise_alpha + hook_handle = embeddings.register_forward_hook(neftune_post_forward_hook) + self.neftune_hook_handle = hook_handle + return model diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1c566fa22f2a6047d848211efab356013e4d9413 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/LLaVA_NeXT/trl/trainer/utils.py @@ -0,0 +1,703 @@ +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import random +import warnings +from collections import deque +from dataclasses import dataclass +from typing import Any, Dict, List, Optional, Tuple, Union + +import numpy as np +import torch +from accelerate import PartialState +from torch.nn.utils.rnn import pad_sequence +from torch.utils.data import IterableDataset +from transformers import BitsAndBytesConfig, DataCollatorForLanguageModeling, PreTrainedTokenizerBase + +from ..import_utils import is_peft_available, is_unsloth_available, is_xpu_available +from ..trainer.model_config import ModelConfig + + +if is_peft_available(): + from peft import LoraConfig, PeftConfig + + +class AdaptiveKLController: + """ + Adaptive KL controller described in the paper: + https://arxiv.org/pdf/1909.08593.pdf + """ + + def __init__(self, init_kl_coef, target, horizon): + self.value = init_kl_coef + self.target = target + self.horizon = horizon + + def update(self, current, n_steps): + target = self.target + proportional_error = np.clip(current / target - 1, -0.2, 0.2) + mult = 1 + proportional_error * n_steps / self.horizon + self.value *= mult + + +class FixedKLController: + """Fixed KL controller.""" + + def __init__(self, kl_coef): + self.value = kl_coef + + def update(self, current, n_steps): + pass + + +class DataCollatorForCompletionOnlyLM(DataCollatorForLanguageModeling): + """ + Data collator used for completion tasks. It ensures that all the tokens of the labels are set to an 'ignore_index' + when they do not come from the assistant. This ensure that the loss is only + calculated on the completion made by the assistant. + + Args: + response_template (`Union[str, List[int]]`): the template form that indicates the start of the response, typically something like + '### Response:\n'. It can also be passed as tokenized ids, which can be useful when using a tokenizer that encodes the response + differently if it does not have proper context. + instruction_template (`Union[str, List[int]]`): the template form that indicates the start of the human instruction, typically something like + '### Human:\n'. Useful for assistant-style conversation datasets. It can also be passed as tokenized ids. + mlm (`bool`, *optional*, defaults to `False`): Whether or not to use masked language modeling in the underlying + `DataCollatorForLanguageModeling` class. Note that this option currently has no effect but is present + for flexibility and backwards-compatibility. + ignore_index (`int`, *optional*, defaults to `-100`): + The index to use to ignore the initial tokens with + """ + + def __init__( + self, + response_template: Union[str, List[int]], + instruction_template: Union[str, List[int]] = None, + *args, + mlm: bool = False, + ignore_index: int = -100, + **kwargs, + ): + super().__init__(*args, mlm=mlm, **kwargs) + + self.instruction_template = instruction_template + if isinstance(instruction_template, str): + # The user provides a string, must tokenize + self.instruction_token_ids = self.tokenizer.encode(self.instruction_template, add_special_tokens=False) + else: + # The user already provides the token ids + self.instruction_token_ids = instruction_template + + self.response_template = response_template + if isinstance(response_template, str): + # The user provides a string, must tokenize + self.response_token_ids = self.tokenizer.encode(self.response_template, add_special_tokens=False) + else: + # The user already provides the token ids + self.response_token_ids = response_template + + if not self.mlm and self.instruction_template and self.tokenizer.pad_token_id == self.tokenizer.eos_token_id: + warnings.warn( + "The pad_token_id and eos_token_id values of this tokenizer are identical. " + "If you are planning for multi-turn training, " + "it can result in the model continuously generating questions and answers without eos token. " + "To avoid this, set the pad_token_id to a different value." + ) + + self.ignore_index = ignore_index + + def torch_call(self, examples: List[Union[List[int], Any, Dict[str, Any]]]) -> Dict[str, Any]: + batch = super().torch_call(examples) + + if self.instruction_template is None: + for i in range(len(examples)): + response_token_ids_start_idx = None + + for idx in np.where(batch["labels"][i] == self.response_token_ids[0])[0]: + # `response_token_ids` is `'### Response:\n'`, here we are just making sure that the token IDs match + if self.response_token_ids == batch["labels"][i][idx : idx + len(self.response_token_ids)].tolist(): + response_token_ids_start_idx = idx + + if response_token_ids_start_idx is None: + warnings.warn( + f"Could not find response key `{self.response_template}` in the " + f'following instance: {self.tokenizer.decode(batch["input_ids"][i])} ' + f"This instance will be ignored in loss calculation. " + f"Note, if this happens often, consider increasing the `max_seq_length`." + ) + batch["labels"][i, :] = self.ignore_index + else: + response_token_ids_end_idx = response_token_ids_start_idx + len(self.response_token_ids) + + # Make pytorch loss function ignore all tokens up through the end of the response key + batch["labels"][i, :response_token_ids_end_idx] = self.ignore_index + + else: + for i in range(len(examples)): + response_token_ids_idxs = [] + human_token_ids_idxs = [] + + for assistant_idx in np.where(batch["labels"][i] == self.response_token_ids[0])[0]: + # find the indexes of the start of a response. + if self.response_token_ids == batch["labels"][i][assistant_idx : assistant_idx + len(self.response_token_ids)].tolist(): + response_token_ids_idxs.append(assistant_idx + len(self.response_token_ids)) + + if len(response_token_ids_idxs) == 0: + warnings.warn( + f"Could not find response key `{self.response_template}` in the " + f'following instance: {self.tokenizer.decode(batch["input_ids"][i])} ' + f"This instance will be ignored in loss calculation. " + f"Note, if this happens often, consider increasing the `max_seq_length`." + ) + batch["labels"][i, :] = self.ignore_index + + human_token_ids = self.instruction_token_ids + for human_idx in np.where(batch["labels"][i] == human_token_ids[0])[0]: + # find the indexes of the start of a human answer. + if human_token_ids == batch["labels"][i][human_idx : human_idx + len(human_token_ids)].tolist(): + human_token_ids_idxs.append(human_idx) + + if len(human_token_ids_idxs) == 0: + warnings.warn( + f"Could not find instruction key `{self.instruction_template}` in the " + f'following instance: {self.tokenizer.decode(batch["input_ids"][i])} ' + f"This instance will be ignored in loss calculation. " + f"Note, if this happens often, consider increasing the `max_seq_length`." + ) + batch["labels"][i, :] = self.ignore_index + + if len(human_token_ids_idxs) > 0 and len(response_token_ids_idxs) > 0 and human_token_ids_idxs[0] > response_token_ids_idxs[0]: + human_token_ids_idxs = [0] + human_token_ids_idxs + + for idx, (start, end) in enumerate(zip(human_token_ids_idxs, response_token_ids_idxs)): + # Make pytorch loss function ignore all non response tokens + if idx != 0: + batch["labels"][i, start:end] = self.ignore_index + else: + batch["labels"][i, :end] = self.ignore_index + + if len(response_token_ids_idxs) < len(human_token_ids_idxs): + batch["labels"][i, human_token_ids_idxs[-1] :] = self.ignore_index + + return batch + + +@dataclass +class RewardDataCollatorWithPadding: + r""" + Reward DataCollator class that pads the inputs to the maximum length of the batch. + Args: + tokenizer (`PreTrainedTokenizerBase`): + The tokenizer used for encoding the data. + padding (`Union[bool, str, `PaddingStrategy`]`, `optional`, defaults to `True`): + padding_strategy to pass to the tokenizer. + max_length (`Optional[int]`, `optional`, defaults to `None`): + The maximum length of the sequence to be processed. + pad_to_multiple_of (`Optional[int]`, `optional`, defaults to `None`): + If set will pad the sequence to a multiple of the provided value. + return_tensors (`str`, `optional`, defaults to `"pt"`): + The tensor type to use. + """ + + tokenizer: PreTrainedTokenizerBase + padding: Union[bool, str] = True + max_length: Optional[int] = None + pad_to_multiple_of: Optional[int] = None + return_tensors: str = "pt" + + def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]: + features_chosen = [] + features_rejected = [] + margin = [] + # check if we have a margin. If we do, we need to batch it as well + has_margin = "margin" in features[0] + for feature in features: + # check if the keys are named as expected + if "input_ids_chosen" not in feature or "input_ids_rejected" not in feature or "attention_mask_chosen" not in feature or "attention_mask_rejected" not in feature: + raise ValueError("The features should include `input_ids_chosen`, `attention_mask_chosen`, `input_ids_rejected` and `attention_mask_rejected`") + + features_chosen.append( + { + "input_ids": feature["input_ids_chosen"], + "attention_mask": feature["attention_mask_chosen"], + } + ) + features_rejected.append( + { + "input_ids": feature["input_ids_rejected"], + "attention_mask": feature["attention_mask_rejected"], + } + ) + if has_margin: + margin.append(feature["margin"]) + batch_chosen = self.tokenizer.pad( + features_chosen, + padding=self.padding, + max_length=self.max_length, + pad_to_multiple_of=self.pad_to_multiple_of, + return_tensors=self.return_tensors, + ) + batch_rejected = self.tokenizer.pad( + features_rejected, + padding=self.padding, + max_length=self.max_length, + pad_to_multiple_of=self.pad_to_multiple_of, + return_tensors=self.return_tensors, + ) + batch = { + "input_ids_chosen": batch_chosen["input_ids"], + "attention_mask_chosen": batch_chosen["attention_mask"], + "input_ids_rejected": batch_rejected["input_ids"], + "attention_mask_rejected": batch_rejected["attention_mask"], + "return_loss": True, + } + if has_margin: + margin = torch.tensor(margin, dtype=torch.float) + batch["margin"] = margin + return batch + + +@dataclass +class DPODataCollatorWithPadding: + r""" + DPO DataCollator class that pads the tokenized inputs to the maximum length of the batch. + Args: + pad_token_id (`int` defaults to 0): + The tokenizer's pad_token_id. + label_pad_token_id (`int`, defaults to -100): + The label used for masking. + is_encoder_decoder (`Optional[bool]`, `optional`, defaults to `None`): + Whether or not you model has an encoder_decoder architecture. + """ + + tokenizer: PreTrainedTokenizerBase + pad_token_id: int = 0 + label_pad_token_id: int = -100 + is_encoder_decoder: Optional[bool] = False + + def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]: + # first, pad everything to the same length + padded_batch = {} + for k in features[0].keys(): + if k.endswith("_input_ids") or k.endswith("_attention_mask") or k.endswith("_labels"): + if self.is_encoder_decoder: + to_pad = [torch.LongTensor(ex[k]) for ex in features] + + if (k.startswith("prompt")) and (k.endswith("input_ids")): + if self.pad_token_id is None: + raise ValueError( + "Padding is enabled, but the tokenizer is not configured with a padding token." " Explicitly set `tokenizer.pad_token` (e.g. `tokenizer.pad_token = tokenizer.eos_token`)" " before calling the trainer." + ) + padding_value = self.pad_token_id + elif k.endswith("_attention_mask"): + padding_value = 0 + elif (k.startswith("chosen")) or (k.startswith("rejected")) or ("decoder" in k): + padding_value = self.label_pad_token_id + else: + raise ValueError(f"Unexpected key in batch '{k}'") + padded_batch[k] = pad_sequence(to_pad, batch_first=True, padding_value=padding_value) + else: + # adapted from https://stackoverflow.com/questions/73256206 + if "prompt" in k: + to_pad = [torch.LongTensor(ex[k][::-1]) for ex in features] + else: + to_pad = [torch.LongTensor(ex[k]) for ex in features] + if k.endswith("_input_ids"): + if self.pad_token_id is None: + raise ValueError( + "Padding is enabled, but the tokenizer is not configured with a padding token." " Explicitly set `tokenizer.pad_token` (e.g. `tokenizer.pad_token = tokenizer.eos_token`)" " before calling the trainer." + ) + padding_value = self.pad_token_id + elif k.endswith("_labels"): + padding_value = self.label_pad_token_id + elif k.endswith("_attention_mask"): + padding_value = 0 + else: + raise ValueError(f"Unexpected key in batch '{k}'") + + padded_batch[k] = pad_sequence(to_pad, batch_first=True, padding_value=padding_value) + # for the prompt, flip back so padding is on left side + if "prompt" in k: + padded_batch[k] = padded_batch[k].flip(dims=[1]) + elif k.endswith("_logps"): + # the cached reference model logprobs + padded_batch[k] = torch.tensor([ex[k] for ex in features]) + else: + padded_batch[k] = [ex[k] for ex in features] + + return padded_batch + + +class ConstantLengthDataset(IterableDataset): + """ + Iterable dataset that returns constant length chunks of tokens from stream of text files. + The dataset also formats the text before tokenization with a specific format that is provided + by the user. + + Args: + tokenizer (`transformers.PreTrainedTokenizer`): + The processor used for processing the data. + dataset (`dataset.Dataset`): + Dataset with text files. + dataset_text_field (`str`, **optional**): + Name of the field in the dataset that contains the text. Used only if `formatting_func` is `None`. + formatting_func (`Callable`, **optional**): + Function that formats the text before tokenization. Usually it is recommended to have follows a certain + pattern such as `"### Question: {question} ### Answer: {answer}"` + infinite (`bool`, *optional*, defaults to `False`): + If True the iterator is reset after dataset reaches end else stops. + seq_length (`int`, *optional*, defaults to `1024`): + Length of token sequences to return. + num_of_sequences (`int`, *optional*, defaults to `1024`): + Number of token sequences to keep in buffer. + chars_per_token (`int`, *optional*, defaults to `3.6`): + Number of characters per token used to estimate number of tokens in text buffer. + eos_token_id (`int`, *optional*, defaults to `0`): + Id of the end of sequence token if the passed tokenizer does not have an EOS token. + shuffle ('bool', *optional*, defaults to True) + Shuffle the examples before they are returned + append_concat_token ('bool', *optional*, defaults to True) + If true, appends `eos_token_id` at the end of each sample being packed. + add_special_tokens ('bool', *optional*, defaults to True) + If true, tokenizers adds special tokens to each sample being packed. + """ + + def __init__( + self, + tokenizer, + dataset, + dataset_text_field=None, + formatting_func=None, + infinite=False, + seq_length=1024, + num_of_sequences=1024, + chars_per_token=3.6, + eos_token_id=0, + shuffle=True, + append_concat_token=True, + add_special_tokens=True, + ): + self.tokenizer = tokenizer + + if tokenizer.eos_token_id is None: + warnings.warn( + "The passed tokenizer does not have an EOS token. We will use the passed eos_token_id instead which corresponds" f" to {eos_token_id}. If this is not the correct EOS token, make sure to pass the correct eos_token_id." + ) + + self.concat_token_id = tokenizer.eos_token_id if tokenizer.eos_token_id else eos_token_id + self.dataset = dataset + self.seq_length = seq_length + self.infinite = infinite + self.current_size = 0 + self.max_buffer_size = seq_length * chars_per_token * num_of_sequences + self.shuffle = shuffle + self.append_concat_token = append_concat_token + self.add_special_tokens = add_special_tokens + if formatting_func is None: + self.formatting_func = lambda x: x[dataset_text_field] + else: + self.formatting_func = formatting_func + + if formatting_func is not None: + if formatting_func.__code__.co_argcount > 1: + warnings.warn( + "The passed formatting_func has more than one argument. Usually that function should have a single argument `example`" + " which corresponds to the dictionary returned by each element of the dataset. Make sure you know what you are doing." + ) + + def __len__(self): + return len(self.dataset) + + def __iter__(self): + iterator = iter(self.dataset) + more_examples = True + while more_examples: + buffer, buffer_len = [], 0 + while True: + if buffer_len >= self.max_buffer_size: + break + try: + buffer.append(self.formatting_func(next(iterator))) + buffer_len += len(buffer[-1]) + except StopIteration: + if self.infinite: + iterator = iter(self.dataset) + warnings.warn("The dataset reached end and the iterator is reset to the start.") + else: + more_examples = False + break + tokenized_inputs = self.tokenizer(buffer, add_special_tokens=self.add_special_tokens, truncation=False)["input_ids"] + all_token_ids = [] + for tokenized_input in tokenized_inputs: + if self.append_concat_token: + tokenized_input = tokenized_input + [self.concat_token_id] + all_token_ids.extend(tokenized_input) + examples = [] + for i in range(0, len(all_token_ids), self.seq_length): + input_ids = all_token_ids[i : i + self.seq_length] + if len(input_ids) == self.seq_length: + examples.append(input_ids) + if self.shuffle: + random.shuffle(examples) + for example in examples: + self.current_size += 1 + yield { + "input_ids": torch.LongTensor(example), + "labels": torch.LongTensor(example), + } + + +class RunningMoments: + def __init__(self, accelerator): + """ + Calculates the running mean and standard deviation of a data stream. Reference: + https://github.com/OpenLMLab/MOSS-RLHF/blob/40b91eb2f2b71b16919addede0341d2bef70825d/utils.py#L75 + """ + self.mean = 0 + self.std = 1 + self.var = 1 + self.count = 1e-24 + self.accelerator = accelerator + + @torch.no_grad() + def update(self, xs: torch.Tensor) -> Tuple[float, float]: + """ + Updates running moments from batch's moments computed across ranks + """ + if self.accelerator.use_distributed: + xs_mean, xs_var, xs_count = get_global_statistics(self.accelerator, xs) + else: + xs_count = xs.numel() + xs_var, xs_mean = torch.var_mean(xs, unbiased=False) + xs_mean, xs_var = xs_mean.float(), xs_var.float() + + delta = xs_mean - self.mean + tot_count = self.count + xs_count + + new_sum = xs_var * xs_count + # correct old_sum deviation accounting for the new mean + old_sum = self.var * self.count + delta**2 * self.count * xs_count / tot_count + tot_sum = old_sum + new_sum + + self.mean += delta * xs_count / tot_count + self.var = tot_sum / tot_count + self.std = (self.var * tot_count / (tot_count - 1)).float().sqrt() + self.count = tot_count + + return xs_mean.item(), (xs_var * xs_count / (xs_count - 1)).float().sqrt().item() + + +@torch.no_grad() +def get_global_statistics(accelerator, xs: torch.Tensor, mask=None, device="cpu") -> Tuple[float, float, int]: + """ + Computes element-wise mean and variance of the tensor across processes. Reference: + https://github.com/OpenLMLab/MOSS-RLHF/blob/40b91eb2f2b71b16919addede0341d2bef70825d/utils.py#L57C1-L73C75 + """ + xs = xs.to(accelerator.device) + sum_and_count = torch.tensor([xs.sum(), (xs.numel() if mask is None else mask.sum())], device=xs.device) + sum_and_count = accelerator.reduce(sum_and_count) + global_sum, count = sum_and_count + global_mean = global_sum / count + + sum_var = torch.sum(((xs - global_mean) ** 2).mul(1 if mask is None else mask)) + sum_var = accelerator.reduce(sum_var) + global_var = sum_var / count + + return global_mean.to(device), global_var.to(device), count.to(device) + + +def compute_accuracy(eval_pred) -> Dict[str, float]: + predictions, labels = eval_pred + # Here, predictions is rewards_chosen and rewards_rejected. + # We want to see how much of the time rewards_chosen > rewards_rejected. + if np.array(predictions[:, 0] == predictions[:, 1], dtype=float).sum() > 0: + warnings.warn(f"There are {np.array(predictions[:, 0] == predictions[:, 1]).sum()} out of {len(predictions[:, 0])} instances where the predictions for both options are equal. As a consequence the accuracy can be misleading.") + predictions = np.argmax(predictions, axis=1) + + accuracy = np.array(predictions == labels, dtype=float).mean().item() + return {"accuracy": accuracy} + + +def pad_to_length(tensor: torch.Tensor, length: int, pad_value: Union[int, float], dim: int = -1) -> torch.Tensor: + if tensor.size(dim) >= length: + return tensor + else: + pad_size = list(tensor.shape) + pad_size[dim] = length - tensor.size(dim) + return torch.cat( + [ + tensor, + pad_value * torch.ones(*pad_size, dtype=tensor.dtype, device=tensor.device), + ], + dim=dim, + ) + + +def disable_dropout_in_model(model: torch.nn.Module) -> None: + for module in model.modules(): + if isinstance(module, torch.nn.Dropout): + module.p = 0 + + +def exact_div(a, b, a_str, b_str, custom_error_message=""): + q = a // b + if a != q * b: + raise ValueError(f"{custom_error_message}, {a_str}={a}, {b_str}={b}, inexact division: {a} / {b} = {a / b}") + return q + + +# copied from https://github.com/kvablack/ddpo-pytorch/blob/main/ddpo_pytorch/stat_tracking.py#L5 +class PerPromptStatTracker: + r""" + Class for tracking statistics per prompt. Mainly used to calculate advantage for the DPPO algorithm + + Args: + buffer_size (`int`): + Size of the buffer to keep for each prompt. + min_count (`int`): + Minimum number of samples to keep in the buffer before calculating the mean and std. + """ + + def __init__(self, buffer_size, min_count): + self.buffer_size = buffer_size + self.min_count = min_count + self.stats = {} + + def update(self, prompts, rewards): + prompts = np.array(prompts) + rewards = np.array(rewards) + unique = np.unique(prompts) + advantages = np.empty_like(rewards) + for prompt in unique: + prompt_rewards = rewards[prompts == prompt] + if prompt not in self.stats: + self.stats[prompt] = deque(maxlen=self.buffer_size) + self.stats[prompt].extend(prompt_rewards) + + if len(self.stats[prompt]) < self.min_count: + mean = np.mean(rewards) + std = np.std(rewards) + 1e-6 + else: + mean = np.mean(self.stats[prompt]) + std = np.std(self.stats[prompt]) + 1e-6 + advantages[prompts == prompt] = (prompt_rewards - mean) / std + + return advantages + + def get_stats(self): + return {k: {"mean": np.mean(v), "std": np.std(v), "count": len(v)} for k, v in self.stats.items()} + + +def neftune_post_forward_hook(module, input, output): + """ + Implements the NEFTune forward pass for the model using forward hooks. Note this works only for + torch.nn.Embedding layers. This method is slightly adapted from the original source code + that can be found here: https://github.com/neelsjain/NEFTune + + Simply add it to your model as follows: + ```python + model = ... + model.embed_tokens.neftune_noise_alpha = 0.1 + model.embed_tokens.register_forward_hook(neftune_post_forward_hook) + ``` + + Args: + module (`torch.nn.Module`): + The embedding module where the hook is attached. Note that you need to set + `module.neftune_noise_alpha` to the desired noise alpha value. + input (`torch.Tensor`): + The input tensor to the model. + output (`torch.Tensor`): + The output tensor of the model (i.e. the embeddings). + """ + if module.training: + dims = torch.tensor(output.size(1) * output.size(2)) + mag_norm = module.neftune_noise_alpha / torch.sqrt(dims) + output = output + torch.zeros_like(output).uniform_(-mag_norm, mag_norm) + return output + + +def peft_module_casting_to_bf16(model): + from peft.tuners.tuners_utils import BaseTunerLayer + + for name, module in model.named_modules(): + if isinstance(module, BaseTunerLayer): + module = module.to(torch.bfloat16) + elif isinstance(module, torch.nn.LayerNorm) or "norm" in name: + module = module.to(torch.float32) + elif any(x in name for x in ["lm_head", "embed_tokens", "wte", "wpe"]): + if hasattr(module, "weight"): + if module.weight.dtype == torch.float32: + module = module.to(torch.bfloat16) + + +def trl_sanitze_kwargs_for_tagging(model, tag_names, kwargs=None): + if is_unsloth_available(): + # Unsloth adds a new attribute in the model config `unsloth_version` + # to keep track of models that have been patched with unsloth. + if hasattr(model, "config") and getattr(model.config, "unsloth_version", None) is not None: + tag_names.append("unsloth") + + if kwargs is not None: + if "tags" not in kwargs: + kwargs["tags"] = tag_names + elif "tags" in kwargs and isinstance(kwargs["tags"], list): + kwargs["tags"].extend(tag_names) + elif "tags" in kwargs and isinstance(kwargs["tags"], str): + tag_names.append(kwargs["tags"]) + kwargs["tags"] = tag_names + return kwargs + + +def get_quantization_config(model_config: ModelConfig) -> Optional[BitsAndBytesConfig]: + if model_config.load_in_4bit: + quantization_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=model_config.torch_dtype, # For consistency with model weights, we use the same value as `torch_dtype` + bnb_4bit_quant_type=model_config.bnb_4bit_quant_type, + bnb_4bit_use_double_quant=model_config.use_bnb_nested_quant, + ) + elif model_config.load_in_8bit: + quantization_config = BitsAndBytesConfig( + load_in_8bit=True, + ) + else: + quantization_config = None + + return quantization_config + + +def get_kbit_device_map() -> Optional[Dict[str, int]]: + if is_xpu_available(): + return {"": f"xpu:{PartialState().local_process_index}"} + elif torch.cuda.is_available(): + return {"": PartialState().local_process_index} + else: + return None + + +def get_peft_config(model_config: ModelConfig) -> "Optional[PeftConfig]": + if model_config.use_peft is False: + return None + + peft_config = LoraConfig( + r=model_config.lora_r, + lora_alpha=model_config.lora_alpha, + lora_dropout=model_config.lora_dropout, + bias="none", + task_type="CAUSAL_LM", + target_modules=model_config.lora_target_modules, + modules_to_save=model_config.lora_modules_to_save, + ) + + return peft_config diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/LICENSE b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..ed13d8404f0f1315ee323b2c8d1b2d8f77b5c82f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/LICENSE @@ -0,0 +1,29 @@ +BSD 3-Clause License + +Copyright (c) 2020, princeton-vl +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/RAFT.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/RAFT.png new file mode 100644 index 0000000000000000000000000000000000000000..176b48c0e7d51e284d86771ae11c1c6afaddb4b1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/RAFT.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3f9fe7730c2289d694d93627b60c272f94ded023ee04a201bd4803dc1028dd09 +size 204077 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/README.md new file mode 100644 index 0000000000000000000000000000000000000000..650275ed7c4cda12822587c6a4358f057fffe494 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/README.md @@ -0,0 +1,80 @@ +# RAFT +This repository contains the source code for our paper: + +[RAFT: Recurrent All Pairs Field Transforms for Optical Flow](https://arxiv.org/pdf/2003.12039.pdf)
+ECCV 2020
+Zachary Teed and Jia Deng
+ + + +## Requirements +The code has been tested with PyTorch 1.6 and Cuda 10.1. +```Shell +conda create --name raft +conda activate raft +conda install pytorch=1.6.0 torchvision=0.7.0 cudatoolkit=10.1 matplotlib tensorboard scipy opencv -c pytorch +``` + +## Demos +Pretrained models can be downloaded by running +```Shell +./download_models.sh +``` +or downloaded from [google drive](https://drive.google.com/drive/folders/1sWDsfuZ3Up38EUQt7-JDTT1HcGHuJgvT?usp=sharing) + +You can demo a trained model on a sequence of frames +```Shell +python demo.py --model=models/raft-things.pth --path=demo-frames +``` + +## Required Data +To evaluate/train RAFT, you will need to download the required datasets. +* [FlyingChairs](https://lmb.informatik.uni-freiburg.de/resources/datasets/FlyingChairs.en.html#flyingchairs) +* [FlyingThings3D](https://lmb.informatik.uni-freiburg.de/resources/datasets/SceneFlowDatasets.en.html) +* [Sintel](http://sintel.is.tue.mpg.de/) +* [KITTI](http://www.cvlibs.net/datasets/kitti/eval_scene_flow.php?benchmark=flow) +* [HD1K](http://hci-benchmark.iwr.uni-heidelberg.de/) (optional) + + +By default `datasets.py` will search for the datasets in these locations. You can create symbolic links to wherever the datasets were downloaded in the `datasets` folder + +```Shell +├── datasets + ├── Sintel + ├── test + ├── training + ├── KITTI + ├── testing + ├── training + ├── devkit + ├── FlyingChairs_release + ├── data + ├── FlyingThings3D + ├── frames_cleanpass + ├── frames_finalpass + ├── optical_flow +``` + +## Evaluation +You can evaluate a trained model using `evaluate.py` +```Shell +python evaluate.py --model=models/raft-things.pth --dataset=sintel --mixed_precision +``` + +## Training +We used the following training schedule in our paper (2 GPUs). Training logs will be written to the `runs` which can be visualized using tensorboard +```Shell +./train_standard.sh +``` + +If you have a RTX GPU, training can be accelerated using mixed precision. You can expect similiar results in this setting (1 GPU) +```Shell +./train_mixed.sh +``` + +## (Optional) Efficent Implementation +You can optionally use our alternate (efficent) implementation by compiling the provided cuda extension +```Shell +cd alt_cuda_corr && python setup.py install && cd .. +``` +and running `demo.py` and `evaluate.py` with the `--alternate_corr` flag Note, this implementation is somewhat slower than all-pairs, but uses significantly less GPU memory during the forward pass. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/correlation.cpp b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/correlation.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b01584d19edb99e7feec5f2e4c51169a1ed208db --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/correlation.cpp @@ -0,0 +1,54 @@ +#include +#include + +// CUDA forward declarations +std::vector corr_cuda_forward( + torch::Tensor fmap1, + torch::Tensor fmap2, + torch::Tensor coords, + int radius); + +std::vector corr_cuda_backward( + torch::Tensor fmap1, + torch::Tensor fmap2, + torch::Tensor coords, + torch::Tensor corr_grad, + int radius); + +// C++ interface +#define CHECK_CUDA(x) TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x) + +std::vector corr_forward( + torch::Tensor fmap1, + torch::Tensor fmap2, + torch::Tensor coords, + int radius) { + CHECK_INPUT(fmap1); + CHECK_INPUT(fmap2); + CHECK_INPUT(coords); + + return corr_cuda_forward(fmap1, fmap2, coords, radius); +} + + +std::vector corr_backward( + torch::Tensor fmap1, + torch::Tensor fmap2, + torch::Tensor coords, + torch::Tensor corr_grad, + int radius) { + CHECK_INPUT(fmap1); + CHECK_INPUT(fmap2); + CHECK_INPUT(coords); + CHECK_INPUT(corr_grad); + + return corr_cuda_backward(fmap1, fmap2, coords, corr_grad, radius); +} + + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &corr_forward, "CORR forward"); + m.def("backward", &corr_backward, "CORR backward"); +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/correlation_kernel.cu b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/correlation_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..145e5804a16ece51b8ff5f1cb61ae8dab4fc3bb7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/correlation_kernel.cu @@ -0,0 +1,324 @@ +#include +#include +#include +#include + + +#define BLOCK_H 4 +#define BLOCK_W 8 +#define BLOCK_HW BLOCK_H * BLOCK_W +#define CHANNEL_STRIDE 32 + + +__forceinline__ __device__ +bool within_bounds(int h, int w, int H, int W) { + return h >= 0 && h < H && w >= 0 && w < W; +} + +template +__global__ void corr_forward_kernel( + const torch::PackedTensorAccessor32 fmap1, + const torch::PackedTensorAccessor32 fmap2, + const torch::PackedTensorAccessor32 coords, + torch::PackedTensorAccessor32 corr, + int r) +{ + const int b = blockIdx.x; + const int h0 = blockIdx.y * blockDim.x; + const int w0 = blockIdx.z * blockDim.y; + const int tid = threadIdx.x * blockDim.y + threadIdx.y; + + const int H1 = fmap1.size(1); + const int W1 = fmap1.size(2); + const int H2 = fmap2.size(1); + const int W2 = fmap2.size(2); + const int N = coords.size(1); + const int C = fmap1.size(3); + + __shared__ scalar_t f1[CHANNEL_STRIDE][BLOCK_HW+1]; + __shared__ scalar_t f2[CHANNEL_STRIDE][BLOCK_HW+1]; + __shared__ scalar_t x2s[BLOCK_HW]; + __shared__ scalar_t y2s[BLOCK_HW]; + + for (int c=0; c(floor(y2s[k1]))-r+iy; + int w2 = static_cast(floor(x2s[k1]))-r+ix; + int c2 = tid % CHANNEL_STRIDE; + + auto fptr = fmap2[b][h2][w2]; + if (within_bounds(h2, w2, H2, W2)) + f2[c2][k1] = fptr[c+c2]; + else + f2[c2][k1] = 0.0; + } + + __syncthreads(); + + scalar_t s = 0.0; + for (int k=0; k 0 && ix > 0 && within_bounds(h1, w1, H1, W1)) + *(corr_ptr + ix_nw) += nw; + + if (iy > 0 && ix < rd && within_bounds(h1, w1, H1, W1)) + *(corr_ptr + ix_ne) += ne; + + if (iy < rd && ix > 0 && within_bounds(h1, w1, H1, W1)) + *(corr_ptr + ix_sw) += sw; + + if (iy < rd && ix < rd && within_bounds(h1, w1, H1, W1)) + *(corr_ptr + ix_se) += se; + } + } + } + } +} + + +template +__global__ void corr_backward_kernel( + const torch::PackedTensorAccessor32 fmap1, + const torch::PackedTensorAccessor32 fmap2, + const torch::PackedTensorAccessor32 coords, + const torch::PackedTensorAccessor32 corr_grad, + torch::PackedTensorAccessor32 fmap1_grad, + torch::PackedTensorAccessor32 fmap2_grad, + torch::PackedTensorAccessor32 coords_grad, + int r) +{ + + const int b = blockIdx.x; + const int h0 = blockIdx.y * blockDim.x; + const int w0 = blockIdx.z * blockDim.y; + const int tid = threadIdx.x * blockDim.y + threadIdx.y; + + const int H1 = fmap1.size(1); + const int W1 = fmap1.size(2); + const int H2 = fmap2.size(1); + const int W2 = fmap2.size(2); + const int N = coords.size(1); + const int C = fmap1.size(3); + + __shared__ scalar_t f1[CHANNEL_STRIDE][BLOCK_HW+1]; + __shared__ scalar_t f2[CHANNEL_STRIDE][BLOCK_HW+1]; + + __shared__ scalar_t f1_grad[CHANNEL_STRIDE][BLOCK_HW+1]; + __shared__ scalar_t f2_grad[CHANNEL_STRIDE][BLOCK_HW+1]; + + __shared__ scalar_t x2s[BLOCK_HW]; + __shared__ scalar_t y2s[BLOCK_HW]; + + for (int c=0; c(floor(y2s[k1]))-r+iy; + int w2 = static_cast(floor(x2s[k1]))-r+ix; + int c2 = tid % CHANNEL_STRIDE; + + auto fptr = fmap2[b][h2][w2]; + if (within_bounds(h2, w2, H2, W2)) + f2[c2][k1] = fptr[c+c2]; + else + f2[c2][k1] = 0.0; + + f2_grad[c2][k1] = 0.0; + } + + __syncthreads(); + + const scalar_t* grad_ptr = &corr_grad[b][n][0][h1][w1]; + scalar_t g = 0.0; + + int ix_nw = H1*W1*((iy-1) + rd*(ix-1)); + int ix_ne = H1*W1*((iy-1) + rd*ix); + int ix_sw = H1*W1*(iy + rd*(ix-1)); + int ix_se = H1*W1*(iy + rd*ix); + + if (iy > 0 && ix > 0 && within_bounds(h1, w1, H1, W1)) + g += *(grad_ptr + ix_nw) * dy * dx; + + if (iy > 0 && ix < rd && within_bounds(h1, w1, H1, W1)) + g += *(grad_ptr + ix_ne) * dy * (1-dx); + + if (iy < rd && ix > 0 && within_bounds(h1, w1, H1, W1)) + g += *(grad_ptr + ix_sw) * (1-dy) * dx; + + if (iy < rd && ix < rd && within_bounds(h1, w1, H1, W1)) + g += *(grad_ptr + ix_se) * (1-dy) * (1-dx); + + for (int k=0; k(floor(y2s[k1]))-r+iy; + int w2 = static_cast(floor(x2s[k1]))-r+ix; + int c2 = tid % CHANNEL_STRIDE; + + scalar_t* fptr = &fmap2_grad[b][h2][w2][0]; + if (within_bounds(h2, w2, H2, W2)) + atomicAdd(fptr+c+c2, f2_grad[c2][k1]); + } + } + } + } + __syncthreads(); + + + for (int k=0; k corr_cuda_forward( + torch::Tensor fmap1, + torch::Tensor fmap2, + torch::Tensor coords, + int radius) +{ + const auto B = coords.size(0); + const auto N = coords.size(1); + const auto H = coords.size(2); + const auto W = coords.size(3); + + const auto rd = 2 * radius + 1; + auto opts = fmap1.options(); + auto corr = torch::zeros({B, N, rd*rd, H, W}, opts); + + const dim3 blocks(B, (H+BLOCK_H-1)/BLOCK_H, (W+BLOCK_W-1)/BLOCK_W); + const dim3 threads(BLOCK_H, BLOCK_W); + + corr_forward_kernel<<>>( + fmap1.packed_accessor32(), + fmap2.packed_accessor32(), + coords.packed_accessor32(), + corr.packed_accessor32(), + radius); + + return {corr}; +} + +std::vector corr_cuda_backward( + torch::Tensor fmap1, + torch::Tensor fmap2, + torch::Tensor coords, + torch::Tensor corr_grad, + int radius) +{ + const auto B = coords.size(0); + const auto N = coords.size(1); + + const auto H1 = fmap1.size(1); + const auto W1 = fmap1.size(2); + const auto H2 = fmap2.size(1); + const auto W2 = fmap2.size(2); + const auto C = fmap1.size(3); + + auto opts = fmap1.options(); + auto fmap1_grad = torch::zeros({B, H1, W1, C}, opts); + auto fmap2_grad = torch::zeros({B, H2, W2, C}, opts); + auto coords_grad = torch::zeros({B, N, H1, W1, 2}, opts); + + const dim3 blocks(B, (H1+BLOCK_H-1)/BLOCK_H, (W1+BLOCK_W-1)/BLOCK_W); + const dim3 threads(BLOCK_H, BLOCK_W); + + + corr_backward_kernel<<>>( + fmap1.packed_accessor32(), + fmap2.packed_accessor32(), + coords.packed_accessor32(), + corr_grad.packed_accessor32(), + fmap1_grad.packed_accessor32(), + fmap2_grad.packed_accessor32(), + coords_grad.packed_accessor32(), + radius); + + return {fmap1_grad, fmap2_grad, coords_grad}; +} \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/setup.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..c0207ff285ffac4c8146c79d154f12416dbef48c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/alt_cuda_corr/setup.py @@ -0,0 +1,15 @@ +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + + +setup( + name='correlation', + ext_modules=[ + CUDAExtension('alt_cuda_corr', + sources=['correlation.cpp', 'correlation_kernel.cu'], + extra_compile_args={'cxx': [], 'nvcc': ['-O3']}), + ], + cmdclass={ + 'build_ext': BuildExtension + }) + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/chairs_split.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/chairs_split.txt new file mode 100644 index 0000000000000000000000000000000000000000..6ae8f0b72a22fc061552604c94664e3a0287914e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/chairs_split.txt @@ -0,0 +1,22872 @@ +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +2 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +1 +1 +1 +1 +1 +1 +1 +2 +1 +1 +1 +1 +1 \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/corr.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/corr.py new file mode 100644 index 0000000000000000000000000000000000000000..32e847bb1f63c81e7ea88a4f173e0e96f5fad5fc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/corr.py @@ -0,0 +1,91 @@ +import torch +import torch.nn.functional as F +from .utils.utils import bilinear_sampler, coords_grid + +try: + import alt_cuda_corr +except: + # alt_cuda_corr is not compiled + pass + + +class CorrBlock: + def __init__(self, fmap1, fmap2, num_levels=4, radius=4): + self.num_levels = num_levels + self.radius = radius + self.corr_pyramid = [] + + # all pairs correlation + corr = CorrBlock.corr(fmap1, fmap2) + + batch, h1, w1, dim, h2, w2 = corr.shape + corr = corr.reshape(batch*h1*w1, dim, h2, w2) + + self.corr_pyramid.append(corr) + for i in range(self.num_levels-1): + corr = F.avg_pool2d(corr, 2, stride=2) + self.corr_pyramid.append(corr) + + def __call__(self, coords): + r = self.radius + coords = coords.permute(0, 2, 3, 1) + batch, h1, w1, _ = coords.shape + + out_pyramid = [] + for i in range(self.num_levels): + corr = self.corr_pyramid[i] + dx = torch.linspace(-r, r, 2*r+1, device=coords.device) + dy = torch.linspace(-r, r, 2*r+1, device=coords.device) + delta = torch.stack(torch.meshgrid(dy, dx), axis=-1) + + centroid_lvl = coords.reshape(batch*h1*w1, 1, 1, 2) / 2**i + delta_lvl = delta.view(1, 2*r+1, 2*r+1, 2) + coords_lvl = centroid_lvl + delta_lvl + + corr = bilinear_sampler(corr, coords_lvl) + corr = corr.view(batch, h1, w1, -1) + out_pyramid.append(corr) + + out = torch.cat(out_pyramid, dim=-1) + return out.permute(0, 3, 1, 2).contiguous().float() + + @staticmethod + def corr(fmap1, fmap2): + batch, dim, ht, wd = fmap1.shape + fmap1 = fmap1.view(batch, dim, ht*wd) + fmap2 = fmap2.view(batch, dim, ht*wd) + + corr = torch.matmul(fmap1.transpose(1,2), fmap2) + corr = corr.view(batch, ht, wd, 1, ht, wd) + return corr / torch.sqrt(torch.tensor(dim).float()) + + +class AlternateCorrBlock: + def __init__(self, fmap1, fmap2, num_levels=4, radius=4): + self.num_levels = num_levels + self.radius = radius + + self.pyramid = [(fmap1, fmap2)] + for i in range(self.num_levels): + fmap1 = F.avg_pool2d(fmap1, 2, stride=2) + fmap2 = F.avg_pool2d(fmap2, 2, stride=2) + self.pyramid.append((fmap1, fmap2)) + + def __call__(self, coords): + coords = coords.permute(0, 2, 3, 1) + B, H, W, _ = coords.shape + dim = self.pyramid[0][0].shape[1] + + corr_list = [] + for i in range(self.num_levels): + r = self.radius + fmap1_i = self.pyramid[0][0].permute(0, 2, 3, 1).contiguous() + fmap2_i = self.pyramid[i][1].permute(0, 2, 3, 1).contiguous() + + coords_i = (coords / 2**i).reshape(B, 1, H, W, 2).contiguous() + corr, = alt_cuda_corr.forward(fmap1_i, fmap2_i, coords_i, r) + corr_list.append(corr.squeeze(1)) + + corr = torch.stack(corr_list, dim=1) + corr = corr.reshape(B, -1, H, W) + return corr / torch.sqrt(torch.tensor(dim).float()) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/datasets.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/datasets.py new file mode 100644 index 0000000000000000000000000000000000000000..3411fdacfb900024005e8997d07c600e963a95ca --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/datasets.py @@ -0,0 +1,235 @@ +# Data loading based on https://github.com/NVIDIA/flownet2-pytorch + +import numpy as np +import torch +import torch.utils.data as data +import torch.nn.functional as F + +import os +import math +import random +from glob import glob +import os.path as osp + +from utils import frame_utils +from utils.augmentor import FlowAugmentor, SparseFlowAugmentor + + +class FlowDataset(data.Dataset): + def __init__(self, aug_params=None, sparse=False): + self.augmentor = None + self.sparse = sparse + if aug_params is not None: + if sparse: + self.augmentor = SparseFlowAugmentor(**aug_params) + else: + self.augmentor = FlowAugmentor(**aug_params) + + self.is_test = False + self.init_seed = False + self.flow_list = [] + self.image_list = [] + self.extra_info = [] + + def __getitem__(self, index): + + if self.is_test: + img1 = frame_utils.read_gen(self.image_list[index][0]) + img2 = frame_utils.read_gen(self.image_list[index][1]) + img1 = np.array(img1).astype(np.uint8)[..., :3] + img2 = np.array(img2).astype(np.uint8)[..., :3] + img1 = torch.from_numpy(img1).permute(2, 0, 1).float() + img2 = torch.from_numpy(img2).permute(2, 0, 1).float() + return img1, img2, self.extra_info[index] + + if not self.init_seed: + worker_info = torch.utils.data.get_worker_info() + if worker_info is not None: + torch.manual_seed(worker_info.id) + np.random.seed(worker_info.id) + random.seed(worker_info.id) + self.init_seed = True + + index = index % len(self.image_list) + valid = None + if self.sparse: + flow, valid = frame_utils.readFlowKITTI(self.flow_list[index]) + else: + flow = frame_utils.read_gen(self.flow_list[index]) + + img1 = frame_utils.read_gen(self.image_list[index][0]) + img2 = frame_utils.read_gen(self.image_list[index][1]) + + flow = np.array(flow).astype(np.float32) + img1 = np.array(img1).astype(np.uint8) + img2 = np.array(img2).astype(np.uint8) + + # grayscale images + if len(img1.shape) == 2: + img1 = np.tile(img1[...,None], (1, 1, 3)) + img2 = np.tile(img2[...,None], (1, 1, 3)) + else: + img1 = img1[..., :3] + img2 = img2[..., :3] + + if self.augmentor is not None: + if self.sparse: + img1, img2, flow, valid = self.augmentor(img1, img2, flow, valid) + else: + img1, img2, flow = self.augmentor(img1, img2, flow) + + img1 = torch.from_numpy(img1).permute(2, 0, 1).float() + img2 = torch.from_numpy(img2).permute(2, 0, 1).float() + flow = torch.from_numpy(flow).permute(2, 0, 1).float() + + if valid is not None: + valid = torch.from_numpy(valid) + else: + valid = (flow[0].abs() < 1000) & (flow[1].abs() < 1000) + + return img1, img2, flow, valid.float() + + + def __rmul__(self, v): + self.flow_list = v * self.flow_list + self.image_list = v * self.image_list + return self + + def __len__(self): + return len(self.image_list) + + +class MpiSintel(FlowDataset): + def __init__(self, aug_params=None, split='training', root='datasets/Sintel', dstype='clean'): + super(MpiSintel, self).__init__(aug_params) + flow_root = osp.join(root, split, 'flow') + image_root = osp.join(root, split, dstype) + + if split == 'test': + self.is_test = True + + for scene in os.listdir(image_root): + image_list = sorted(glob(osp.join(image_root, scene, '*.png'))) + for i in range(len(image_list)-1): + self.image_list += [ [image_list[i], image_list[i+1]] ] + self.extra_info += [ (scene, i) ] # scene and frame_id + + if split != 'test': + self.flow_list += sorted(glob(osp.join(flow_root, scene, '*.flo'))) + + +class FlyingChairs(FlowDataset): + def __init__(self, aug_params=None, split='train', root='datasets/FlyingChairs_release/data'): + super(FlyingChairs, self).__init__(aug_params) + + images = sorted(glob(osp.join(root, '*.ppm'))) + flows = sorted(glob(osp.join(root, '*.flo'))) + assert (len(images)//2 == len(flows)) + + split_list = np.loadtxt('chairs_split.txt', dtype=np.int32) + for i in range(len(flows)): + xid = split_list[i] + if (split=='training' and xid==1) or (split=='validation' and xid==2): + self.flow_list += [ flows[i] ] + self.image_list += [ [images[2*i], images[2*i+1]] ] + + +class FlyingThings3D(FlowDataset): + def __init__(self, aug_params=None, root='datasets/FlyingThings3D', dstype='frames_cleanpass'): + super(FlyingThings3D, self).__init__(aug_params) + + for cam in ['left']: + for direction in ['into_future', 'into_past']: + image_dirs = sorted(glob(osp.join(root, dstype, 'TRAIN/*/*'))) + image_dirs = sorted([osp.join(f, cam) for f in image_dirs]) + + flow_dirs = sorted(glob(osp.join(root, 'optical_flow/TRAIN/*/*'))) + flow_dirs = sorted([osp.join(f, direction, cam) for f in flow_dirs]) + + for idir, fdir in zip(image_dirs, flow_dirs): + images = sorted(glob(osp.join(idir, '*.png')) ) + flows = sorted(glob(osp.join(fdir, '*.pfm')) ) + for i in range(len(flows)-1): + if direction == 'into_future': + self.image_list += [ [images[i], images[i+1]] ] + self.flow_list += [ flows[i] ] + elif direction == 'into_past': + self.image_list += [ [images[i+1], images[i]] ] + self.flow_list += [ flows[i+1] ] + + +class KITTI(FlowDataset): + def __init__(self, aug_params=None, split='training', root='datasets/KITTI'): + super(KITTI, self).__init__(aug_params, sparse=True) + if split == 'testing': + self.is_test = True + + root = osp.join(root, split) + images1 = sorted(glob(osp.join(root, 'image_2/*_10.png'))) + images2 = sorted(glob(osp.join(root, 'image_2/*_11.png'))) + + for img1, img2 in zip(images1, images2): + frame_id = img1.split('/')[-1] + self.extra_info += [ [frame_id] ] + self.image_list += [ [img1, img2] ] + + if split == 'training': + self.flow_list = sorted(glob(osp.join(root, 'flow_occ/*_10.png'))) + + +class HD1K(FlowDataset): + def __init__(self, aug_params=None, root='datasets/HD1k'): + super(HD1K, self).__init__(aug_params, sparse=True) + + seq_ix = 0 + while 1: + flows = sorted(glob(os.path.join(root, 'hd1k_flow_gt', 'flow_occ/%06d_*.png' % seq_ix))) + images = sorted(glob(os.path.join(root, 'hd1k_input', 'image_2/%06d_*.png' % seq_ix))) + + if len(flows) == 0: + break + + for i in range(len(flows)-1): + self.flow_list += [flows[i]] + self.image_list += [ [images[i], images[i+1]] ] + + seq_ix += 1 + + +def fetch_dataloader(args, TRAIN_DS='C+T+K+S+H'): + """ Create the data loader for the corresponding trainign set """ + + if args.stage == 'chairs': + aug_params = {'crop_size': args.image_size, 'min_scale': -0.1, 'max_scale': 1.0, 'do_flip': True} + train_dataset = FlyingChairs(aug_params, split='training') + + elif args.stage == 'things': + aug_params = {'crop_size': args.image_size, 'min_scale': -0.4, 'max_scale': 0.8, 'do_flip': True} + clean_dataset = FlyingThings3D(aug_params, dstype='frames_cleanpass') + final_dataset = FlyingThings3D(aug_params, dstype='frames_finalpass') + train_dataset = clean_dataset + final_dataset + + elif args.stage == 'sintel': + aug_params = {'crop_size': args.image_size, 'min_scale': -0.2, 'max_scale': 0.6, 'do_flip': True} + things = FlyingThings3D(aug_params, dstype='frames_cleanpass') + sintel_clean = MpiSintel(aug_params, split='training', dstype='clean') + sintel_final = MpiSintel(aug_params, split='training', dstype='final') + + if TRAIN_DS == 'C+T+K+S+H': + kitti = KITTI({'crop_size': args.image_size, 'min_scale': -0.3, 'max_scale': 0.5, 'do_flip': True}) + hd1k = HD1K({'crop_size': args.image_size, 'min_scale': -0.5, 'max_scale': 0.2, 'do_flip': True}) + train_dataset = 100*sintel_clean + 100*sintel_final + 200*kitti + 5*hd1k + things + + elif TRAIN_DS == 'C+T+K/S': + train_dataset = 100*sintel_clean + 100*sintel_final + things + + elif args.stage == 'kitti': + aug_params = {'crop_size': args.image_size, 'min_scale': -0.2, 'max_scale': 0.4, 'do_flip': False} + train_dataset = KITTI(aug_params, split='training') + + train_loader = data.DataLoader(train_dataset, batch_size=args.batch_size, + pin_memory=False, shuffle=True, num_workers=4, drop_last=True) + + print('Training with %d image pairs' % len(train_dataset)) + return train_loader + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/extractor.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/extractor.py new file mode 100644 index 0000000000000000000000000000000000000000..9a9c759d1243d4694e8656c2f6f8a37e53edd009 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/extractor.py @@ -0,0 +1,267 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class ResidualBlock(nn.Module): + def __init__(self, in_planes, planes, norm_fn='group', stride=1): + super(ResidualBlock, self).__init__() + + self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1) + self.relu = nn.ReLU(inplace=True) + + num_groups = planes // 8 + + if norm_fn == 'group': + self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes) + self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes) + if not stride == 1: + self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes) + + elif norm_fn == 'batch': + self.norm1 = nn.BatchNorm2d(planes) + self.norm2 = nn.BatchNorm2d(planes) + if not stride == 1: + self.norm3 = nn.BatchNorm2d(planes) + + elif norm_fn == 'instance': + self.norm1 = nn.InstanceNorm2d(planes) + self.norm2 = nn.InstanceNorm2d(planes) + if not stride == 1: + self.norm3 = nn.InstanceNorm2d(planes) + + elif norm_fn == 'none': + self.norm1 = nn.Sequential() + self.norm2 = nn.Sequential() + if not stride == 1: + self.norm3 = nn.Sequential() + + if stride == 1: + self.downsample = None + + else: + self.downsample = nn.Sequential( + nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm3) + + + def forward(self, x): + y = x + y = self.relu(self.norm1(self.conv1(y))) + y = self.relu(self.norm2(self.conv2(y))) + + if self.downsample is not None: + x = self.downsample(x) + + return self.relu(x+y) + + + +class BottleneckBlock(nn.Module): + def __init__(self, in_planes, planes, norm_fn='group', stride=1): + super(BottleneckBlock, self).__init__() + + self.conv1 = nn.Conv2d(in_planes, planes//4, kernel_size=1, padding=0) + self.conv2 = nn.Conv2d(planes//4, planes//4, kernel_size=3, padding=1, stride=stride) + self.conv3 = nn.Conv2d(planes//4, planes, kernel_size=1, padding=0) + self.relu = nn.ReLU(inplace=True) + + num_groups = planes // 8 + + if norm_fn == 'group': + self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes//4) + self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes//4) + self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes) + if not stride == 1: + self.norm4 = nn.GroupNorm(num_groups=num_groups, num_channels=planes) + + elif norm_fn == 'batch': + self.norm1 = nn.BatchNorm2d(planes//4) + self.norm2 = nn.BatchNorm2d(planes//4) + self.norm3 = nn.BatchNorm2d(planes) + if not stride == 1: + self.norm4 = nn.BatchNorm2d(planes) + + elif norm_fn == 'instance': + self.norm1 = nn.InstanceNorm2d(planes//4) + self.norm2 = nn.InstanceNorm2d(planes//4) + self.norm3 = nn.InstanceNorm2d(planes) + if not stride == 1: + self.norm4 = nn.InstanceNorm2d(planes) + + elif norm_fn == 'none': + self.norm1 = nn.Sequential() + self.norm2 = nn.Sequential() + self.norm3 = nn.Sequential() + if not stride == 1: + self.norm4 = nn.Sequential() + + if stride == 1: + self.downsample = None + + else: + self.downsample = nn.Sequential( + nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm4) + + + def forward(self, x): + y = x + y = self.relu(self.norm1(self.conv1(y))) + y = self.relu(self.norm2(self.conv2(y))) + y = self.relu(self.norm3(self.conv3(y))) + + if self.downsample is not None: + x = self.downsample(x) + + return self.relu(x+y) + +class BasicEncoder(nn.Module): + def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0): + super(BasicEncoder, self).__init__() + self.norm_fn = norm_fn + + if self.norm_fn == 'group': + self.norm1 = nn.GroupNorm(num_groups=8, num_channels=64) + + elif self.norm_fn == 'batch': + self.norm1 = nn.BatchNorm2d(64) + + elif self.norm_fn == 'instance': + self.norm1 = nn.InstanceNorm2d(64) + + elif self.norm_fn == 'none': + self.norm1 = nn.Sequential() + + self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3) + self.relu1 = nn.ReLU(inplace=True) + + self.in_planes = 64 + self.layer1 = self._make_layer(64, stride=1) + self.layer2 = self._make_layer(96, stride=2) + self.layer3 = self._make_layer(128, stride=2) + + # output convolution + self.conv2 = nn.Conv2d(128, output_dim, kernel_size=1) + + self.dropout = None + if dropout > 0: + self.dropout = nn.Dropout2d(p=dropout) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)): + if m.weight is not None: + nn.init.constant_(m.weight, 1) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def _make_layer(self, dim, stride=1): + layer1 = ResidualBlock(self.in_planes, dim, self.norm_fn, stride=stride) + layer2 = ResidualBlock(dim, dim, self.norm_fn, stride=1) + layers = (layer1, layer2) + + self.in_planes = dim + return nn.Sequential(*layers) + + + def forward(self, x): + + # if input is list, combine batch dimension + is_list = isinstance(x, tuple) or isinstance(x, list) + if is_list: + batch_dim = x[0].shape[0] + x = torch.cat(x, dim=0) + + x = self.conv1(x) + x = self.norm1(x) + x = self.relu1(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + + x = self.conv2(x) + + if self.training and self.dropout is not None: + x = self.dropout(x) + + if is_list: + x = torch.split(x, [batch_dim, batch_dim], dim=0) + + return x + + +class SmallEncoder(nn.Module): + def __init__(self, output_dim=128, norm_fn='batch', dropout=0.0): + super(SmallEncoder, self).__init__() + self.norm_fn = norm_fn + + if self.norm_fn == 'group': + self.norm1 = nn.GroupNorm(num_groups=8, num_channels=32) + + elif self.norm_fn == 'batch': + self.norm1 = nn.BatchNorm2d(32) + + elif self.norm_fn == 'instance': + self.norm1 = nn.InstanceNorm2d(32) + + elif self.norm_fn == 'none': + self.norm1 = nn.Sequential() + + self.conv1 = nn.Conv2d(3, 32, kernel_size=7, stride=2, padding=3) + self.relu1 = nn.ReLU(inplace=True) + + self.in_planes = 32 + self.layer1 = self._make_layer(32, stride=1) + self.layer2 = self._make_layer(64, stride=2) + self.layer3 = self._make_layer(96, stride=2) + + self.dropout = None + if dropout > 0: + self.dropout = nn.Dropout2d(p=dropout) + + self.conv2 = nn.Conv2d(96, output_dim, kernel_size=1) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)): + if m.weight is not None: + nn.init.constant_(m.weight, 1) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def _make_layer(self, dim, stride=1): + layer1 = BottleneckBlock(self.in_planes, dim, self.norm_fn, stride=stride) + layer2 = BottleneckBlock(dim, dim, self.norm_fn, stride=1) + layers = (layer1, layer2) + + self.in_planes = dim + return nn.Sequential(*layers) + + + def forward(self, x): + + # if input is list, combine batch dimension + is_list = isinstance(x, tuple) or isinstance(x, list) + if is_list: + batch_dim = x[0].shape[0] + x = torch.cat(x, dim=0) + + x = self.conv1(x) + x = self.norm1(x) + x = self.relu1(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.conv2(x) + + if self.training and self.dropout is not None: + x = self.dropout(x) + + if is_list: + x = torch.split(x, [batch_dim, batch_dim], dim=0) + + return x diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/raft.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/raft.py new file mode 100644 index 0000000000000000000000000000000000000000..8ed2e719df513d9d7d0e43558726c2d65d2bdb09 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/raft.py @@ -0,0 +1,144 @@ +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .update import BasicUpdateBlock, SmallUpdateBlock +from .extractor import BasicEncoder, SmallEncoder +from .corr import CorrBlock, AlternateCorrBlock +from .utils.utils import bilinear_sampler, coords_grid, upflow8 + +try: + autocast = torch.cuda.autocast +except: + # dummy autocast for PyTorch < 1.6 + class autocast: + def __init__(self, enabled): + pass + def __enter__(self): + pass + def __exit__(self, *args): + pass + + +class RAFT(nn.Module): + def __init__(self, args): + super(RAFT, self).__init__() + self.args = args + + if args.small: + self.hidden_dim = hdim = 96 + self.context_dim = cdim = 64 + args.corr_levels = 4 + args.corr_radius = 3 + + else: + self.hidden_dim = hdim = 128 + self.context_dim = cdim = 128 + args.corr_levels = 4 + args.corr_radius = 4 + + if 'dropout' not in self.args: + self.args.dropout = 0 + + if 'alternate_corr' not in self.args: + self.args.alternate_corr = False + + # feature network, context network, and update block + if args.small: + self.fnet = SmallEncoder(output_dim=128, norm_fn='instance', dropout=args.dropout) + self.cnet = SmallEncoder(output_dim=hdim+cdim, norm_fn='none', dropout=args.dropout) + self.update_block = SmallUpdateBlock(self.args, hidden_dim=hdim) + + else: + self.fnet = BasicEncoder(output_dim=256, norm_fn='instance', dropout=args.dropout) + self.cnet = BasicEncoder(output_dim=hdim+cdim, norm_fn='batch', dropout=args.dropout) + self.update_block = BasicUpdateBlock(self.args, hidden_dim=hdim) + + def freeze_bn(self): + for m in self.modules(): + if isinstance(m, nn.BatchNorm2d): + m.eval() + + def initialize_flow(self, img): + """ Flow is represented as difference between two coordinate grids flow = coords1 - coords0""" + N, C, H, W = img.shape + coords0 = coords_grid(N, H//8, W//8, device=img.device) + coords1 = coords_grid(N, H//8, W//8, device=img.device) + + # optical flow computed as difference: flow = coords1 - coords0 + return coords0, coords1 + + def upsample_flow(self, flow, mask): + """ Upsample flow field [H/8, W/8, 2] -> [H, W, 2] using convex combination """ + N, _, H, W = flow.shape + mask = mask.view(N, 1, 9, 8, 8, H, W) + mask = torch.softmax(mask, dim=2) + + up_flow = F.unfold(8 * flow, [3,3], padding=1) + up_flow = up_flow.view(N, 2, 9, 1, 1, H, W) + + up_flow = torch.sum(mask * up_flow, dim=2) + up_flow = up_flow.permute(0, 1, 4, 2, 5, 3) + return up_flow.reshape(N, 2, 8*H, 8*W) + + + def forward(self, image1, image2, iters=12, flow_init=None, upsample=True, test_mode=False): + """ Estimate optical flow between pair of frames """ + + image1 = 2 * (image1 / 255.0) - 1.0 + image2 = 2 * (image2 / 255.0) - 1.0 + + image1 = image1.contiguous() + image2 = image2.contiguous() + + hdim = self.hidden_dim + cdim = self.context_dim + + # run the feature network + with autocast(enabled=self.args.mixed_precision): + fmap1, fmap2 = self.fnet([image1, image2]) + + fmap1 = fmap1.float() + fmap2 = fmap2.float() + if self.args.alternate_corr: + corr_fn = AlternateCorrBlock(fmap1, fmap2, radius=self.args.corr_radius) + else: + corr_fn = CorrBlock(fmap1, fmap2, radius=self.args.corr_radius) + + # run the context network + with autocast(enabled=self.args.mixed_precision): + cnet = self.cnet(image1) + net, inp = torch.split(cnet, [hdim, cdim], dim=1) + net = torch.tanh(net) + inp = torch.relu(inp) + + coords0, coords1 = self.initialize_flow(image1) + + if flow_init is not None: + coords1 = coords1 + flow_init + + flow_predictions = [] + for itr in range(iters): + coords1 = coords1.detach() + corr = corr_fn(coords1) # index correlation volume + + flow = coords1 - coords0 + with autocast(enabled=self.args.mixed_precision): + net, up_mask, delta_flow = self.update_block(net, inp, corr, flow) + + # F(t+1) = F(t) + \Delta(t) + coords1 = coords1 + delta_flow + + # upsample predictions + if up_mask is None: + flow_up = upflow8(coords1 - coords0) + else: + flow_up = self.upsample_flow(coords1 - coords0, up_mask) + + flow_predictions.append(flow_up) + + if test_mode: + return coords1 - coords0, flow_up + + return flow_predictions diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/update.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/update.py new file mode 100644 index 0000000000000000000000000000000000000000..f940497f9b5eb1c12091574fe9a0223a1b196d50 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/update.py @@ -0,0 +1,139 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class FlowHead(nn.Module): + def __init__(self, input_dim=128, hidden_dim=256): + super(FlowHead, self).__init__() + self.conv1 = nn.Conv2d(input_dim, hidden_dim, 3, padding=1) + self.conv2 = nn.Conv2d(hidden_dim, 2, 3, padding=1) + self.relu = nn.ReLU(inplace=True) + + def forward(self, x): + return self.conv2(self.relu(self.conv1(x))) + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + h = (1-z) * h + z * q + return h + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + +class SmallMotionEncoder(nn.Module): + def __init__(self, args): + super(SmallMotionEncoder, self).__init__() + cor_planes = args.corr_levels * (2*args.corr_radius + 1)**2 + self.convc1 = nn.Conv2d(cor_planes, 96, 1, padding=0) + self.convf1 = nn.Conv2d(2, 64, 7, padding=3) + self.convf2 = nn.Conv2d(64, 32, 3, padding=1) + self.conv = nn.Conv2d(128, 80, 3, padding=1) + + def forward(self, flow, corr): + cor = F.relu(self.convc1(corr)) + flo = F.relu(self.convf1(flow)) + flo = F.relu(self.convf2(flo)) + cor_flo = torch.cat([cor, flo], dim=1) + out = F.relu(self.conv(cor_flo)) + return torch.cat([out, flow], dim=1) + +class BasicMotionEncoder(nn.Module): + def __init__(self, args): + super(BasicMotionEncoder, self).__init__() + cor_planes = args.corr_levels * (2*args.corr_radius + 1)**2 + self.convc1 = nn.Conv2d(cor_planes, 256, 1, padding=0) + self.convc2 = nn.Conv2d(256, 192, 3, padding=1) + self.convf1 = nn.Conv2d(2, 128, 7, padding=3) + self.convf2 = nn.Conv2d(128, 64, 3, padding=1) + self.conv = nn.Conv2d(64+192, 128-2, 3, padding=1) + + def forward(self, flow, corr): + cor = F.relu(self.convc1(corr)) + cor = F.relu(self.convc2(cor)) + flo = F.relu(self.convf1(flow)) + flo = F.relu(self.convf2(flo)) + + cor_flo = torch.cat([cor, flo], dim=1) + out = F.relu(self.conv(cor_flo)) + return torch.cat([out, flow], dim=1) + +class SmallUpdateBlock(nn.Module): + def __init__(self, args, hidden_dim=96): + super(SmallUpdateBlock, self).__init__() + self.encoder = SmallMotionEncoder(args) + self.gru = ConvGRU(hidden_dim=hidden_dim, input_dim=82+64) + self.flow_head = FlowHead(hidden_dim, hidden_dim=128) + + def forward(self, net, inp, corr, flow): + motion_features = self.encoder(flow, corr) + inp = torch.cat([inp, motion_features], dim=1) + net = self.gru(net, inp) + delta_flow = self.flow_head(net) + + return net, None, delta_flow + +class BasicUpdateBlock(nn.Module): + def __init__(self, args, hidden_dim=128, input_dim=128): + super(BasicUpdateBlock, self).__init__() + self.args = args + self.encoder = BasicMotionEncoder(args) + self.gru = SepConvGRU(hidden_dim=hidden_dim, input_dim=128+hidden_dim) + self.flow_head = FlowHead(hidden_dim, hidden_dim=256) + + self.mask = nn.Sequential( + nn.Conv2d(128, 256, 3, padding=1), + nn.ReLU(inplace=True), + nn.Conv2d(256, 64*9, 1, padding=0)) + + def forward(self, net, inp, corr, flow, upsample=True): + motion_features = self.encoder(flow, corr) + inp = torch.cat([inp, motion_features], dim=1) + + net = self.gru(net, inp) + delta_flow = self.flow_head(net) + + # scale mask to balence gradients + mask = .25 * self.mask(net) + return net, mask, delta_flow + + + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/augmentor.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/augmentor.py new file mode 100644 index 0000000000000000000000000000000000000000..e81c4f2b5c16c31c0ae236d744f299d430228a04 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/augmentor.py @@ -0,0 +1,246 @@ +import numpy as np +import random +import math +from PIL import Image + +import cv2 +cv2.setNumThreads(0) +cv2.ocl.setUseOpenCL(False) + +import torch +from torchvision.transforms import ColorJitter +import torch.nn.functional as F + + +class FlowAugmentor: + def __init__(self, crop_size, min_scale=-0.2, max_scale=0.5, do_flip=True): + + # spatial augmentation params + self.crop_size = crop_size + self.min_scale = min_scale + self.max_scale = max_scale + self.spatial_aug_prob = 0.8 + self.stretch_prob = 0.8 + self.max_stretch = 0.2 + + # flip augmentation params + self.do_flip = do_flip + self.h_flip_prob = 0.5 + self.v_flip_prob = 0.1 + + # photometric augmentation params + self.photo_aug = ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.5/3.14) + self.asymmetric_color_aug_prob = 0.2 + self.eraser_aug_prob = 0.5 + + def color_transform(self, img1, img2): + """ Photometric augmentation """ + + # asymmetric + if np.random.rand() < self.asymmetric_color_aug_prob: + img1 = np.array(self.photo_aug(Image.fromarray(img1)), dtype=np.uint8) + img2 = np.array(self.photo_aug(Image.fromarray(img2)), dtype=np.uint8) + + # symmetric + else: + image_stack = np.concatenate([img1, img2], axis=0) + image_stack = np.array(self.photo_aug(Image.fromarray(image_stack)), dtype=np.uint8) + img1, img2 = np.split(image_stack, 2, axis=0) + + return img1, img2 + + def eraser_transform(self, img1, img2, bounds=[50, 100]): + """ Occlusion augmentation """ + + ht, wd = img1.shape[:2] + if np.random.rand() < self.eraser_aug_prob: + mean_color = np.mean(img2.reshape(-1, 3), axis=0) + for _ in range(np.random.randint(1, 3)): + x0 = np.random.randint(0, wd) + y0 = np.random.randint(0, ht) + dx = np.random.randint(bounds[0], bounds[1]) + dy = np.random.randint(bounds[0], bounds[1]) + img2[y0:y0+dy, x0:x0+dx, :] = mean_color + + return img1, img2 + + def spatial_transform(self, img1, img2, flow): + # randomly sample scale + ht, wd = img1.shape[:2] + min_scale = np.maximum( + (self.crop_size[0] + 8) / float(ht), + (self.crop_size[1] + 8) / float(wd)) + + scale = 2 ** np.random.uniform(self.min_scale, self.max_scale) + scale_x = scale + scale_y = scale + if np.random.rand() < self.stretch_prob: + scale_x *= 2 ** np.random.uniform(-self.max_stretch, self.max_stretch) + scale_y *= 2 ** np.random.uniform(-self.max_stretch, self.max_stretch) + + scale_x = np.clip(scale_x, min_scale, None) + scale_y = np.clip(scale_y, min_scale, None) + + if np.random.rand() < self.spatial_aug_prob: + # rescale the images + img1 = cv2.resize(img1, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR) + img2 = cv2.resize(img2, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR) + flow = cv2.resize(flow, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR) + flow = flow * [scale_x, scale_y] + + if self.do_flip: + if np.random.rand() < self.h_flip_prob: # h-flip + img1 = img1[:, ::-1] + img2 = img2[:, ::-1] + flow = flow[:, ::-1] * [-1.0, 1.0] + + if np.random.rand() < self.v_flip_prob: # v-flip + img1 = img1[::-1, :] + img2 = img2[::-1, :] + flow = flow[::-1, :] * [1.0, -1.0] + + y0 = np.random.randint(0, img1.shape[0] - self.crop_size[0]) + x0 = np.random.randint(0, img1.shape[1] - self.crop_size[1]) + + img1 = img1[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + img2 = img2[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + flow = flow[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + + return img1, img2, flow + + def __call__(self, img1, img2, flow): + img1, img2 = self.color_transform(img1, img2) + img1, img2 = self.eraser_transform(img1, img2) + img1, img2, flow = self.spatial_transform(img1, img2, flow) + + img1 = np.ascontiguousarray(img1) + img2 = np.ascontiguousarray(img2) + flow = np.ascontiguousarray(flow) + + return img1, img2, flow + +class SparseFlowAugmentor: + def __init__(self, crop_size, min_scale=-0.2, max_scale=0.5, do_flip=False): + # spatial augmentation params + self.crop_size = crop_size + self.min_scale = min_scale + self.max_scale = max_scale + self.spatial_aug_prob = 0.8 + self.stretch_prob = 0.8 + self.max_stretch = 0.2 + + # flip augmentation params + self.do_flip = do_flip + self.h_flip_prob = 0.5 + self.v_flip_prob = 0.1 + + # photometric augmentation params + self.photo_aug = ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.3/3.14) + self.asymmetric_color_aug_prob = 0.2 + self.eraser_aug_prob = 0.5 + + def color_transform(self, img1, img2): + image_stack = np.concatenate([img1, img2], axis=0) + image_stack = np.array(self.photo_aug(Image.fromarray(image_stack)), dtype=np.uint8) + img1, img2 = np.split(image_stack, 2, axis=0) + return img1, img2 + + def eraser_transform(self, img1, img2): + ht, wd = img1.shape[:2] + if np.random.rand() < self.eraser_aug_prob: + mean_color = np.mean(img2.reshape(-1, 3), axis=0) + for _ in range(np.random.randint(1, 3)): + x0 = np.random.randint(0, wd) + y0 = np.random.randint(0, ht) + dx = np.random.randint(50, 100) + dy = np.random.randint(50, 100) + img2[y0:y0+dy, x0:x0+dx, :] = mean_color + + return img1, img2 + + def resize_sparse_flow_map(self, flow, valid, fx=1.0, fy=1.0): + ht, wd = flow.shape[:2] + coords = np.meshgrid(np.arange(wd), np.arange(ht)) + coords = np.stack(coords, axis=-1) + + coords = coords.reshape(-1, 2).astype(np.float32) + flow = flow.reshape(-1, 2).astype(np.float32) + valid = valid.reshape(-1).astype(np.float32) + + coords0 = coords[valid>=1] + flow0 = flow[valid>=1] + + ht1 = int(round(ht * fy)) + wd1 = int(round(wd * fx)) + + coords1 = coords0 * [fx, fy] + flow1 = flow0 * [fx, fy] + + xx = np.round(coords1[:,0]).astype(np.int32) + yy = np.round(coords1[:,1]).astype(np.int32) + + v = (xx > 0) & (xx < wd1) & (yy > 0) & (yy < ht1) + xx = xx[v] + yy = yy[v] + flow1 = flow1[v] + + flow_img = np.zeros([ht1, wd1, 2], dtype=np.float32) + valid_img = np.zeros([ht1, wd1], dtype=np.int32) + + flow_img[yy, xx] = flow1 + valid_img[yy, xx] = 1 + + return flow_img, valid_img + + def spatial_transform(self, img1, img2, flow, valid): + # randomly sample scale + + ht, wd = img1.shape[:2] + min_scale = np.maximum( + (self.crop_size[0] + 1) / float(ht), + (self.crop_size[1] + 1) / float(wd)) + + scale = 2 ** np.random.uniform(self.min_scale, self.max_scale) + scale_x = np.clip(scale, min_scale, None) + scale_y = np.clip(scale, min_scale, None) + + if np.random.rand() < self.spatial_aug_prob: + # rescale the images + img1 = cv2.resize(img1, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR) + img2 = cv2.resize(img2, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR) + flow, valid = self.resize_sparse_flow_map(flow, valid, fx=scale_x, fy=scale_y) + + if self.do_flip: + if np.random.rand() < 0.5: # h-flip + img1 = img1[:, ::-1] + img2 = img2[:, ::-1] + flow = flow[:, ::-1] * [-1.0, 1.0] + valid = valid[:, ::-1] + + margin_y = 20 + margin_x = 50 + + y0 = np.random.randint(0, img1.shape[0] - self.crop_size[0] + margin_y) + x0 = np.random.randint(-margin_x, img1.shape[1] - self.crop_size[1] + margin_x) + + y0 = np.clip(y0, 0, img1.shape[0] - self.crop_size[0]) + x0 = np.clip(x0, 0, img1.shape[1] - self.crop_size[1]) + + img1 = img1[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + img2 = img2[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + flow = flow[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + valid = valid[y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]] + return img1, img2, flow, valid + + + def __call__(self, img1, img2, flow, valid): + img1, img2 = self.color_transform(img1, img2) + img1, img2 = self.eraser_transform(img1, img2) + img1, img2, flow, valid = self.spatial_transform(img1, img2, flow, valid) + + img1 = np.ascontiguousarray(img1) + img2 = np.ascontiguousarray(img2) + flow = np.ascontiguousarray(flow) + valid = np.ascontiguousarray(valid) + + return img1, img2, flow, valid diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/flow_viz.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/flow_viz.py new file mode 100644 index 0000000000000000000000000000000000000000..dcee65e89b91b07ee0496aeb4c7e7436abf99641 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/flow_viz.py @@ -0,0 +1,132 @@ +# Flow visualization code used from https://github.com/tomrunia/OpticalFlow_Visualization + + +# MIT License +# +# Copyright (c) 2018 Tom Runia +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to conditions. +# +# Author: Tom Runia +# Date Created: 2018-08-03 + +import numpy as np + +def make_colorwheel(): + """ + Generates a color wheel for optical flow visualization as presented in: + Baker et al. "A Database and Evaluation Methodology for Optical Flow" (ICCV, 2007) + URL: http://vision.middlebury.edu/flow/flowEval-iccv07.pdf + + Code follows the original C++ source code of Daniel Scharstein. + Code follows the the Matlab source code of Deqing Sun. + + Returns: + np.ndarray: Color wheel + """ + + RY = 15 + YG = 6 + GC = 4 + CB = 11 + BM = 13 + MR = 6 + + ncols = RY + YG + GC + CB + BM + MR + colorwheel = np.zeros((ncols, 3)) + col = 0 + + # RY + colorwheel[0:RY, 0] = 255 + colorwheel[0:RY, 1] = np.floor(255*np.arange(0,RY)/RY) + col = col+RY + # YG + colorwheel[col:col+YG, 0] = 255 - np.floor(255*np.arange(0,YG)/YG) + colorwheel[col:col+YG, 1] = 255 + col = col+YG + # GC + colorwheel[col:col+GC, 1] = 255 + colorwheel[col:col+GC, 2] = np.floor(255*np.arange(0,GC)/GC) + col = col+GC + # CB + colorwheel[col:col+CB, 1] = 255 - np.floor(255*np.arange(CB)/CB) + colorwheel[col:col+CB, 2] = 255 + col = col+CB + # BM + colorwheel[col:col+BM, 2] = 255 + colorwheel[col:col+BM, 0] = np.floor(255*np.arange(0,BM)/BM) + col = col+BM + # MR + colorwheel[col:col+MR, 2] = 255 - np.floor(255*np.arange(MR)/MR) + colorwheel[col:col+MR, 0] = 255 + return colorwheel + + +def flow_uv_to_colors(u, v, convert_to_bgr=False): + """ + Applies the flow color wheel to (possibly clipped) flow components u and v. + + According to the C++ source code of Daniel Scharstein + According to the Matlab source code of Deqing Sun + + Args: + u (np.ndarray): Input horizontal flow of shape [H,W] + v (np.ndarray): Input vertical flow of shape [H,W] + convert_to_bgr (bool, optional): Convert output image to BGR. Defaults to False. + + Returns: + np.ndarray: Flow visualization image of shape [H,W,3] + """ + flow_image = np.zeros((u.shape[0], u.shape[1], 3), np.uint8) + colorwheel = make_colorwheel() # shape [55x3] + ncols = colorwheel.shape[0] + rad = np.sqrt(np.square(u) + np.square(v)) + a = np.arctan2(-v, -u)/np.pi + fk = (a+1) / 2*(ncols-1) + k0 = np.floor(fk).astype(np.int32) + k1 = k0 + 1 + k1[k1 == ncols] = 0 + f = fk - k0 + for i in range(colorwheel.shape[1]): + tmp = colorwheel[:,i] + col0 = tmp[k0] / 255.0 + col1 = tmp[k1] / 255.0 + col = (1-f)*col0 + f*col1 + idx = (rad <= 1) + col[idx] = 1 - rad[idx] * (1-col[idx]) + col[~idx] = col[~idx] * 0.75 # out of range + # Note the 2-i => BGR instead of RGB + ch_idx = 2-i if convert_to_bgr else i + flow_image[:,:,ch_idx] = np.floor(255 * col) + return flow_image + + +def flow_to_image(flow_uv, clip_flow=None, convert_to_bgr=False): + """ + Expects a two dimensional flow image of shape. + + Args: + flow_uv (np.ndarray): Flow UV image of shape [H,W,2] + clip_flow (float, optional): Clip maximum of flow values. Defaults to None. + convert_to_bgr (bool, optional): Convert output image to BGR. Defaults to False. + + Returns: + np.ndarray: Flow visualization image of shape [H,W,3] + """ + assert flow_uv.ndim == 3, 'input flow must have three dimensions' + assert flow_uv.shape[2] == 2, 'input flow must have shape [H,W,2]' + if clip_flow is not None: + flow_uv = np.clip(flow_uv, 0, clip_flow) + u = flow_uv[:,:,0] + v = flow_uv[:,:,1] + rad = np.sqrt(np.square(u) + np.square(v)) + rad_max = np.max(rad) + epsilon = 1e-5 + u = u / (rad_max + epsilon) + v = v / (rad_max + epsilon) + return flow_uv_to_colors(u, v, convert_to_bgr) \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/frame_utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/frame_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..6c491135efaffc25bd61ec3ecde99d236f5deb12 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/frame_utils.py @@ -0,0 +1,137 @@ +import numpy as np +from PIL import Image +from os.path import * +import re + +import cv2 +cv2.setNumThreads(0) +cv2.ocl.setUseOpenCL(False) + +TAG_CHAR = np.array([202021.25], np.float32) + +def readFlow(fn): + """ Read .flo file in Middlebury format""" + # Code adapted from: + # http://stackoverflow.com/questions/28013200/reading-middlebury-flow-files-with-python-bytes-array-numpy + + # WARNING: this will work on little-endian architectures (eg Intel x86) only! + # print 'fn = %s'%(fn) + with open(fn, 'rb') as f: + magic = np.fromfile(f, np.float32, count=1) + if 202021.25 != magic: + print('Magic number incorrect. Invalid .flo file') + return None + else: + w = np.fromfile(f, np.int32, count=1) + h = np.fromfile(f, np.int32, count=1) + # print 'Reading %d x %d flo file\n' % (w, h) + data = np.fromfile(f, np.float32, count=2*int(w)*int(h)) + # Reshape data into 3D array (columns, rows, bands) + # The reshape here is for visualization, the original code is (w,h,2) + return np.resize(data, (int(h), int(w), 2)) + +def readPFM(file): + file = open(file, 'rb') + + color = None + width = None + height = None + scale = None + endian = None + + header = file.readline().rstrip() + if header == b'PF': + color = True + elif header == b'Pf': + color = False + else: + raise Exception('Not a PFM file.') + + dim_match = re.match(rb'^(\d+)\s(\d+)\s$', file.readline()) + if dim_match: + width, height = map(int, dim_match.groups()) + else: + raise Exception('Malformed PFM header.') + + scale = float(file.readline().rstrip()) + if scale < 0: # little-endian + endian = '<' + scale = -scale + else: + endian = '>' # big-endian + + data = np.fromfile(file, endian + 'f') + shape = (height, width, 3) if color else (height, width) + + data = np.reshape(data, shape) + data = np.flipud(data) + return data + +def writeFlow(filename,uv,v=None): + """ Write optical flow to file. + + If v is None, uv is assumed to contain both u and v channels, + stacked in depth. + Original code by Deqing Sun, adapted from Daniel Scharstein. + """ + nBands = 2 + + if v is None: + assert(uv.ndim == 3) + assert(uv.shape[2] == 2) + u = uv[:,:,0] + v = uv[:,:,1] + else: + u = uv + + assert(u.shape == v.shape) + height,width = u.shape + f = open(filename,'wb') + # write the header + f.write(TAG_CHAR) + np.array(width).astype(np.int32).tofile(f) + np.array(height).astype(np.int32).tofile(f) + # arrange into matrix form + tmp = np.zeros((height, width*nBands)) + tmp[:,np.arange(width)*2] = u + tmp[:,np.arange(width)*2 + 1] = v + tmp.astype(np.float32).tofile(f) + f.close() + + +def readFlowKITTI(filename): + flow = cv2.imread(filename, cv2.IMREAD_ANYDEPTH|cv2.IMREAD_COLOR) + flow = flow[:,:,::-1].astype(np.float32) + flow, valid = flow[:, :, :2], flow[:, :, 2] + flow = (flow - 2**15) / 64.0 + return flow, valid + +def readDispKITTI(filename): + disp = cv2.imread(filename, cv2.IMREAD_ANYDEPTH) / 256.0 + valid = disp > 0.0 + flow = np.stack([-disp, np.zeros_like(disp)], -1) + return flow, valid + + +def writeFlowKITTI(filename, uv): + uv = 64.0 * uv + 2**15 + valid = np.ones([uv.shape[0], uv.shape[1], 1]) + uv = np.concatenate([uv, valid], axis=-1).astype(np.uint16) + cv2.imwrite(filename, uv[..., ::-1]) + + +def read_gen(file_name, pil=False): + ext = splitext(file_name)[-1] + if ext == '.png' or ext == '.jpeg' or ext == '.ppm' or ext == '.jpg': + return Image.open(file_name) + elif ext == '.bin' or ext == '.raw': + return np.load(file_name) + elif ext == '.flo': + return readFlow(file_name).astype(np.float32) + elif ext == '.pfm': + flow = readPFM(file_name).astype(np.float32) + if len(flow.shape) == 2: + return flow + else: + return flow[:, :, :-1] + return [] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/utils.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..741ccfe4d0d778c3199c586d368edc2882d4fff8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/core/utils/utils.py @@ -0,0 +1,82 @@ +import torch +import torch.nn.functional as F +import numpy as np +from scipy import interpolate + + +class InputPadder: + """ Pads images such that dimensions are divisible by 8 """ + def __init__(self, dims, mode='sintel'): + self.ht, self.wd = dims[-2:] + pad_ht = (((self.ht // 8) + 1) * 8 - self.ht) % 8 + pad_wd = (((self.wd // 8) + 1) * 8 - self.wd) % 8 + if mode == 'sintel': + self._pad = [pad_wd//2, pad_wd - pad_wd//2, pad_ht//2, pad_ht - pad_ht//2] + else: + self._pad = [pad_wd//2, pad_wd - pad_wd//2, 0, pad_ht] + + def pad(self, *inputs): + return [F.pad(x, self._pad, mode='replicate') for x in inputs] + + def unpad(self,x): + ht, wd = x.shape[-2:] + c = [self._pad[2], ht-self._pad[3], self._pad[0], wd-self._pad[1]] + return x[..., c[0]:c[1], c[2]:c[3]] + +def forward_interpolate(flow): + flow = flow.detach().cpu().numpy() + dx, dy = flow[0], flow[1] + + ht, wd = dx.shape + x0, y0 = np.meshgrid(np.arange(wd), np.arange(ht)) + + x1 = x0 + dx + y1 = y0 + dy + + x1 = x1.reshape(-1) + y1 = y1.reshape(-1) + dx = dx.reshape(-1) + dy = dy.reshape(-1) + + valid = (x1 > 0) & (x1 < wd) & (y1 > 0) & (y1 < ht) + x1 = x1[valid] + y1 = y1[valid] + dx = dx[valid] + dy = dy[valid] + + flow_x = interpolate.griddata( + (x1, y1), dx, (x0, y0), method='nearest', fill_value=0) + + flow_y = interpolate.griddata( + (x1, y1), dy, (x0, y0), method='nearest', fill_value=0) + + flow = np.stack([flow_x, flow_y], axis=0) + return torch.from_numpy(flow).float() + + +def bilinear_sampler(img, coords, mode='bilinear', mask=False): + """ Wrapper for grid_sample, uses pixel coordinates """ + H, W = img.shape[-2:] + xgrid, ygrid = coords.split([1,1], dim=-1) + xgrid = 2*xgrid/(W-1) - 1 + ygrid = 2*ygrid/(H-1) - 1 + + grid = torch.cat([xgrid, ygrid], dim=-1) + img = F.grid_sample(img, grid, align_corners=True) + + if mask: + mask = (xgrid > -1) & (ygrid > -1) & (xgrid < 1) & (ygrid < 1) + return img, mask.float() + + return img + + +def coords_grid(batch, ht, wd, device): + coords = torch.meshgrid(torch.arange(ht, device=device), torch.arange(wd, device=device)) + coords = torch.stack(coords[::-1], dim=0).float() + return coords[None].repeat(batch, 1, 1, 1) + + +def upflow8(flow, mode='bilinear'): + new_size = (8 * flow.shape[2], 8 * flow.shape[3]) + return 8 * F.interpolate(flow, size=new_size, mode=mode, align_corners=True) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/download_models.sh b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/download_models.sh new file mode 100644 index 0000000000000000000000000000000000000000..dfd8d473f461edd999716fd38fe7ee32f5a39235 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/RAFT/download_models.sh @@ -0,0 +1,3 @@ +#!/bin/bash +wget https://dl.dropboxusercontent.com/s/4j4z58wuv8o0mfz/models.zip +unzip models.zip diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/1.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..017697c88641b8ca67dd5f745aa053d610584ab9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/1.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52d4d9d97db7dd59f0b530c15eed1d9e0c8129380dcb82405bf9b9e1e462d834 +size 1823172 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/2.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f12762f58ce417d753246fdd813c6318a1c5351d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/2.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d20226bb84dc57ebc5706cc8cbc15864677f5fb367910f0f3f1ba0886a7f476e +size 1177620 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/3.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d16a383258453bfac34ddd216549627fb983e5a9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/3.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbf5c21934861dfc44d28c3829407d3d02d0599c31f095c2681f7e69c613121e +size 1738432 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/4.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a8ab4e999ed04e17bb189b37a05285f1ca0f6b4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/4.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:facec69807e37fe24bf28914bf6157549aa76c1577e1645c51d4103df603b9d8 +size 2890640 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/anomaly.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/anomaly.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dabf7e16530f6404b7a9caea1649cb24ba475fff --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/anomaly.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a760ef13e9b63be1bfa003aaf52db604a4d76148309e8511b6768a49e8165c89 +size 164525 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/anomaly_framework.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/anomaly_framework.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a99cb7befd1ae51d49aaa8977a30b75c9778ea3a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/anomaly_framework.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1ebe30a0ba81781917585adb1c87f4121f61672f64bdd8b2e5fd9b99583bb40 +size 53739 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/data_process.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/data_process.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31778887b5e12ad200a34232448e86f8f7678635 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/data_process.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64af70cca265b1cbfd2d41070002ac8a098ad1614cd9c4e0ac26d3238c3f786a +size 74823 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/fig.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/fig.png new file mode 100644 index 0000000000000000000000000000000000000000..556f995f727e3ac3cbd0b9de418a302bda88eb39 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/fig.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f91925bf0be833b94cc4de3c887d8637d49194cdba22cac8e1ef5649b18510c +size 3640951 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/fig1.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/fig1.png new file mode 100644 index 0000000000000000000000000000000000000000..989f66b18528a34b850936b525ede133ccff48ca --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/assets/fig1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8f5ffecae123d93e989d2663e9ee2f7ce7d99bc59f2539bd59f7573a53a568d2 +size 3180308 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/config.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/config.py new file mode 100644 index 0000000000000000000000000000000000000000..58b2863f08126610bb1881be7437e2a4e52929a1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/config.py @@ -0,0 +1,286 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +import os +import yaml +from yacs.config import CfgNode as CN + +_C = CN() + +# Base config files +_C.BASE = [''] + +# ----------------------------------------------------------------------------- +# Data settings +# ----------------------------------------------------------------------------- +_C.DATA = CN() +# Batch size for a single GPU, could be overwritten by command line argument +_C.DATA.BATCH_SIZE = 128 +# Path to dataset, could be overwritten by command line argument +_C.DATA.DATA_PATH = '' +_C.DATA.TRAIN_PATH = '' +_C.DATA.VAL_PATH = '' +# Dataset name +_C.DATA.DATASET = 'imagenet' +# Input image size +_C.DATA.IMG_SIZE = 224 +# Interpolation to resize image (random, bilinear, bicubic) +_C.DATA.INTERPOLATION = 'bicubic' +# Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU. +_C.DATA.PIN_MEMORY = True +# Number of data loading threads +_C.DATA.NUM_WORKERS = 8 + +# [SimMIM] Mask patch size for MaskGenerator +_C.DATA.MASK_PATCH_SIZE = 32 +# [SimMIM] Mask ratio for MaskGenerator +_C.DATA.MASK_RATIO = 0.6 + +# ----------------------------------------------------------------------------- +# Model settings +# ----------------------------------------------------------------------------- +_C.MODEL = CN() +# Model type +_C.MODEL.TYPE = 'swin' +# Model name +_C.MODEL.NAME = 'swin_tiny_patch4_window7_224' +# Checkpoint to resume, could be overwritten by command line argument +_C.MODEL.RESUME = '' +# Number of classes, overwritten in data preparation +_C.MODEL.NUM_CLASSES = 2 +# Dropout rate +_C.MODEL.DROP_RATE = 0.0 +# Drop path rate +_C.MODEL.DROP_PATH_RATE = 0.1 +# Label Smoothing +_C.MODEL.LABEL_SMOOTHING = 0.1 + +# Swin Transformer parameters +_C.MODEL.SWIN = CN() +_C.MODEL.SWIN.PATCH_SIZE = 4 +_C.MODEL.SWIN.IN_CHANS = 3 +_C.MODEL.SWIN.EMBED_DIM = 96 +_C.MODEL.SWIN.DEPTHS = [2, 2, 6, 2] +_C.MODEL.SWIN.NUM_HEADS = [3, 6, 12, 24] +_C.MODEL.SWIN.WINDOW_SIZE = 7 +_C.MODEL.SWIN.MLP_RATIO = 4. +_C.MODEL.SWIN.QKV_BIAS = True +_C.MODEL.SWIN.QK_SCALE = None +_C.MODEL.SWIN.APE = False +_C.MODEL.SWIN.PATCH_NORM = True + +# Vision Transformer parameters +_C.MODEL.VIT = CN() +_C.MODEL.VIT.PATCH_SIZE = 16 +_C.MODEL.VIT.IN_CHANS = 3 +_C.MODEL.VIT.EMBED_DIM = 768 +_C.MODEL.VIT.DEPTH = 12 +_C.MODEL.VIT.NUM_HEADS = 12 +_C.MODEL.VIT.MLP_RATIO = 4 +_C.MODEL.VIT.QKV_BIAS = True +_C.MODEL.VIT.INIT_VALUES = 0.1 +_C.MODEL.VIT.USE_APE = False +_C.MODEL.VIT.USE_RPB = False +_C.MODEL.VIT.USE_SHARED_RPB = True +_C.MODEL.VIT.USE_MEAN_POOLING = False + +# ----------------------------------------------------------------------------- +# Training settings +# ----------------------------------------------------------------------------- +_C.TRAIN = CN() +_C.TRAIN.START_EPOCH = 0 +_C.TRAIN.EPOCHS = 300 +_C.TRAIN.WARMUP_EPOCHS = 20 +_C.TRAIN.WEIGHT_DECAY = 0.05 +_C.TRAIN.BASE_LR = 5e-4 +_C.TRAIN.WARMUP_LR = 5e-7 +_C.TRAIN.MIN_LR = 5e-6 +# Clip gradient norm +_C.TRAIN.CLIP_GRAD = 5.0 +# Auto resume from latest checkpoint +_C.TRAIN.AUTO_RESUME = True +# Gradient accumulation steps +# could be overwritten by command line argument +_C.TRAIN.ACCUMULATION_STEPS = 0 +# Whether to use gradient checkpointing to save memory +# could be overwritten by command line argument +_C.TRAIN.USE_CHECKPOINT = False + +# LR scheduler +_C.TRAIN.LR_SCHEDULER = CN() +_C.TRAIN.LR_SCHEDULER.NAME = 'cosine' +# Epoch interval to decay LR, used in StepLRScheduler +_C.TRAIN.LR_SCHEDULER.DECAY_EPOCHS = 30 +# LR decay rate, used in StepLRScheduler +_C.TRAIN.LR_SCHEDULER.DECAY_RATE = 0.1 +# Gamma / Multi steps value, used in MultiStepLRScheduler +_C.TRAIN.LR_SCHEDULER.GAMMA = 0.1 +_C.TRAIN.LR_SCHEDULER.MULTISTEPS = [] + +# Optimizer +_C.TRAIN.OPTIMIZER = CN() +_C.TRAIN.OPTIMIZER.NAME = 'adamw' +# Optimizer Epsilon +_C.TRAIN.OPTIMIZER.EPS = 1e-8 +# Optimizer Betas +_C.TRAIN.OPTIMIZER.BETAS = (0.9, 0.999) +# SGD momentum +_C.TRAIN.OPTIMIZER.MOMENTUM = 0.9 + +# [SimMIM] Layer decay for fine-tuning +_C.TRAIN.LAYER_DECAY = 1.0 + +_C.LOSS = CN() +# Loss function +_C.LOSS.FOCAL = False +_C.LOSS.FOCAL_ALPHA = 0.25 +_C.LOSS.FOCAL_GAMMA = 2.0 +# ----------------------------------------------------------------------------- +# Augmentation settings +# ----------------------------------------------------------------------------- +_C.AUG = CN() +# Color jitter factor +_C.AUG.COLOR_JITTER = 0.4 +# Use AutoAugment policy. "v0" or "original" +_C.AUG.AUTO_AUGMENT = 'rand-m9-mstd0.5-inc1' +# Random erase prob +_C.AUG.REPROB = 0.25 +# Random erase mode +_C.AUG.REMODE = 'pixel' +# Random erase count +_C.AUG.RECOUNT = 1 +# Mixup alpha, mixup enabled if > 0 +_C.AUG.MIXUP = 0.8 +# Cutmix alpha, cutmix enabled if > 0 +_C.AUG.CUTMIX = 1.0 +# Cutmix min/max ratio, overrides alpha and enables cutmix if set +_C.AUG.CUTMIX_MINMAX = None +# Probability of performing mixup or cutmix when either/both is enabled +_C.AUG.MIXUP_PROB = 1.0 +# Probability of switching to cutmix when both mixup and cutmix enabled +_C.AUG.MIXUP_SWITCH_PROB = 0.5 +# How to apply mixup/cutmix params. Per "batch", "pair", or "elem" +_C.AUG.MIXUP_MODE = 'batch' + +# ----------------------------------------------------------------------------- +# Testing settings +# ----------------------------------------------------------------------------- +_C.TEST = CN() +# Whether to use center crop when testing +_C.TEST.CROP = True + +# ----------------------------------------------------------------------------- +# Misc +# ----------------------------------------------------------------------------- +# Mixed precision opt level, if O0, no amp is used ('O0', 'O1', 'O2') +# overwritten by command line argument +_C.AMP_OPT_LEVEL = '' +# Path to output folder, overwritten by command line argument +_C.OUTPUT = '' +# Tag of experiment, overwritten by command line argument +_C.TAG = 'default' +# Frequency to save checkpoint +_C.SAVE_FREQ = 1 +# Frequency to logging info +_C.PRINT_FREQ = 10 +# Fixed random seed +_C.SEED = 0 +# Perform evaluation only, overwritten by command line argument +_C.EVAL_MODE = False +# Test throughput only, overwritten by command line argument +_C.THROUGHPUT_MODE = False +# local rank for DistributedDataParallel, given by command line argument +_C.LOCAL_RANK = 0 + +# [SimMIM] path to pre-trained model +_C.PRETRAINED = '' + + +def _update_config_from_file(config, cfg_file): + config.defrost() + with open(cfg_file, 'r') as f: + yaml_cfg = yaml.load(f, Loader=yaml.FullLoader) + + for cfg in yaml_cfg.setdefault('BASE', ['']): + if cfg: + _update_config_from_file( + config, os.path.join(os.path.dirname(cfg_file), cfg) + ) + print('=> merge config from {}'.format(cfg_file)) + config.merge_from_file(cfg_file) + config.freeze() + + +def update_config(config, args): + _update_config_from_file(config, args.cfg) + + config.defrost() + if args.opts: + config.merge_from_list(args.opts) + + def _check_args(name): + if hasattr(args, name) and eval(f'args.{name}'): + return True + return False + + # merge from specific arguments + if _check_args('batch_size'): + config.DATA.BATCH_SIZE = args.batch_size + if _check_args('train_path'): + config.DATA.TRAIN_PATH = args.train_path + if _check_args('val_path'): + config.DATA.VAL_PATH = args.val_path + if _check_args('resume'): + config.MODEL.RESUME = args.resume + if _check_args('pretrained'): + config.PRETRAINED = args.pretrained + if _check_args('accumulation_steps'): + config.TRAIN.ACCUMULATION_STEPS = args.accumulation_steps + if _check_args('use_checkpoint'): + config.TRAIN.USE_CHECKPOINT = True + if _check_args('amp_opt_level'): + config.AMP_OPT_LEVEL = args.amp_opt_level + if _check_args('output'): + config.OUTPUT = args.output + if _check_args('tag'): + config.TAG = args.tag + if _check_args('eval'): + config.EVAL_MODE = True + if _check_args('throughput'): + config.THROUGHPUT_MODE = True + + if _check_args('focal_loss'): + config.LOSS.FOCAL = args.focal_loss + if config.LOSS.FOCAL: + config.AUG.MIXUP = 0.0 + config.AUG.CUTMIX = 0.0 + config.MODEL.LABEL_SMOOTHING = 0.0 + if _check_args('focal_alpha'): + config.LOSS.FOCAL_ALPHA = args.focal_alpha + if _check_args('focal_gamma'): + config.LOSS.FOCAL_GAMMA = args.focal_gamma + + # set local rank for distributed training + config.LOCAL_RANK = args.local_rank + + # output folder + config.OUTPUT = os.path.join(config.OUTPUT, config.MODEL.NAME, config.TAG) + + + config.AMP_OPT_LEVEL = "O0" + config.freeze() + + +def get_config(args): + """Get a yacs CfgNode object with default values.""" + # Return a clone so that the defaults will not be altered + # This is for the "local variable" use pattern + config = _C.clone() + update_config(config, args) + + return config diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_finetune__swin_base__img192_window6__100ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_finetune__swin_base__img192_window6__100ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fdb6877d28ec1c80b4e340b93114cef4cd2f6a08 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_finetune__swin_base__img192_window6__100ep.yaml @@ -0,0 +1,22 @@ +MODEL: + TYPE: swin + NAME: simmim_finetune + DROP_PATH_RATE: 0.1 + SWIN: + EMBED_DIM: 128 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 6 +DATA: + IMG_SIZE: 192 +TRAIN: + EPOCHS: 100 + WARMUP_EPOCHS: 20 + BASE_LR: 1.25e-3 + WARMUP_LR: 2.5e-7 + MIN_LR: 2.5e-7 + WEIGHT_DECAY: 0.05 + LAYER_DECAY: 0.9 +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_finetune__swin_base__img192_window6__100ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_finetune__swin_base__img224_window7__100ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_finetune__swin_base__img224_window7__100ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fb79113b104ab1b3a634e6971093cd446a8c1dc0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_finetune__swin_base__img224_window7__100ep.yaml @@ -0,0 +1,22 @@ +MODEL: + TYPE: swin + NAME: simmim_finetune + DROP_PATH_RATE: 0.1 + SWIN: + EMBED_DIM: 128 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 7 +DATA: + IMG_SIZE: 224 +TRAIN: + EPOCHS: 100 + WARMUP_EPOCHS: 20 + BASE_LR: 1.25e-3 + WARMUP_LR: 2.5e-7 + MIN_LR: 2.5e-7 + WEIGHT_DECAY: 0.05 + LAYER_DECAY: 0.9 +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_finetune__swin_base__img224_window7__100ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_pretrain__swin_base__img192_window6__100ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_pretrain__swin_base__img192_window6__100ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b2ea0167781b6ecbb48028eba095a3f926b6123e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__100ep/simmim_pretrain__swin_base__img192_window6__100ep.yaml @@ -0,0 +1,23 @@ +MODEL: + TYPE: swin + NAME: simmim_pretrain + DROP_PATH_RATE: 0.0 + SWIN: + EMBED_DIM: 128 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 6 +DATA: + IMG_SIZE: 192 + MASK_PATCH_SIZE: 32 + MASK_RATIO: 0.6 +TRAIN: + EPOCHS: 100 + WARMUP_EPOCHS: 10 + BASE_LR: 2e-4 + WARMUP_LR: 1e-6 + MIN_LR: 1e-5 + WEIGHT_DECAY: 0.05 +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_pretrain__swin_base__img192_window6__100ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__800ep/simmim_finetune__swin_base__img224_window7__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__800ep/simmim_finetune__swin_base__img224_window7__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b13906708121f455586a6bddc5a259db4d82a894 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__800ep/simmim_finetune__swin_base__img224_window7__800ep.yaml @@ -0,0 +1,22 @@ +MODEL: + TYPE: swin + NAME: simmim_finetune + DROP_PATH_RATE: 0.1 + SWIN: + EMBED_DIM: 128 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 7 +DATA: + IMG_SIZE: 224 +TRAIN: + EPOCHS: 100 + WARMUP_EPOCHS: 20 + BASE_LR: 1.25e-3 + WARMUP_LR: 2.5e-7 + MIN_LR: 2.5e-7 + WEIGHT_DECAY: 0.05 + LAYER_DECAY: 0.8 +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_finetune__swin_base__img224_window7__800ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__800ep/simmim_pretrain__swin_base__img192_window6__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__800ep/simmim_pretrain__swin_base__img192_window6__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..92da90aba803c0c268dc4cd896dac2c7c4b01dee --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_base__800ep/simmim_pretrain__swin_base__img192_window6__800ep.yaml @@ -0,0 +1,26 @@ +MODEL: + TYPE: swin + NAME: simmim_pretrain + DROP_PATH_RATE: 0.0 + SWIN: + EMBED_DIM: 128 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 6 +DATA: + IMG_SIZE: 192 + MASK_PATCH_SIZE: 32 + MASK_RATIO: 0.6 +TRAIN: + EPOCHS: 800 + WARMUP_EPOCHS: 10 + BASE_LR: 1e-4 + WARMUP_LR: 5e-7 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_pretrain__swin_base__img192_window6__800ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_large__800ep/simmim_finetune__swin_large__img224_window14__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_large__800ep/simmim_finetune__swin_large__img224_window14__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3e805413dba928f4c96c90dda9ecacdc639809b3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_large__800ep/simmim_finetune__swin_large__img224_window14__800ep.yaml @@ -0,0 +1,22 @@ +MODEL: + TYPE: swin + NAME: simmim_finetune + DROP_PATH_RATE: 0.2 + SWIN: + EMBED_DIM: 192 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 6, 12, 24, 48 ] + WINDOW_SIZE: 14 +DATA: + IMG_SIZE: 224 +TRAIN: + EPOCHS: 100 + WARMUP_EPOCHS: 20 + BASE_LR: 1.25e-3 + WARMUP_LR: 2.5e-7 + MIN_LR: 2.5e-7 + WEIGHT_DECAY: 0.05 + LAYER_DECAY: 0.7 +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_finetune__swin_large__img224_window14__800ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_large__800ep/simmim_pretrain__swin_large__img192_window12__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_large__800ep/simmim_pretrain__swin_large__img192_window12__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5494530a91d586e1dd3de4aeb1229724b41966f5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/swin_large__800ep/simmim_pretrain__swin_large__img192_window12__800ep.yaml @@ -0,0 +1,26 @@ +MODEL: + TYPE: swin + NAME: simmim_pretrain + DROP_PATH_RATE: 0.0 + SWIN: + EMBED_DIM: 192 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 6, 12, 24, 48 ] + WINDOW_SIZE: 12 +DATA: + IMG_SIZE: 192 + MASK_PATCH_SIZE: 32 + MASK_RATIO: 0.6 +TRAIN: + EPOCHS: 800 + WARMUP_EPOCHS: 10 + BASE_LR: 1e-4 + WARMUP_LR: 5e-7 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_pretrain__swin_large__img192_window12__800ep \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/vit_base__800ep/simmim_finetune__vit_base__img224__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/vit_base__800ep/simmim_finetune__vit_base__img224__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..13f584bf9449fd38166bbfb4f1b1334ccbff2e93 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/vit_base__800ep/simmim_finetune__vit_base__img224__800ep.yaml @@ -0,0 +1,25 @@ +MODEL: + TYPE: vit + NAME: simmim_finetune + DROP_PATH_RATE: 0.1 + VIT: + EMBED_DIM: 768 + DEPTH: 12 + NUM_HEADS: 12 + USE_APE: False + USE_RPB: True + USE_SHARED_RPB: False + USE_MEAN_POOLING: True +DATA: + IMG_SIZE: 224 +TRAIN: + EPOCHS: 30 + WARMUP_EPOCHS: 3 + BASE_LR: 1.25e-3 + WARMUP_LR: 2.5e-7 + MIN_LR: 2.5e-7 + WEIGHT_DECAY: 0.05 + LAYER_DECAY: 0.65 +PRINT_FREQ: 2 +SAVE_FREQ: 5 +TAG: simmim_finetune__vit_base__img224__800ep diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/vit_base__800ep/simmim_pretrain__vit_base__img224__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/vit_base__800ep/simmim_pretrain__vit_base__img224__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3ac2bbda547430b906793e45c8720f0c2ee7ffa3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/vit_base__800ep/simmim_pretrain__vit_base__img224__800ep.yaml @@ -0,0 +1,29 @@ +MODEL: + TYPE: vit + NAME: simmim_pretrain + DROP_PATH_RATE: 0.1 + VIT: + EMBED_DIM: 768 + DEPTH: 12 + NUM_HEADS: 12 + USE_APE: False + USE_RPB: False + USE_SHARED_RPB: True + USE_MEAN_POOLING: False +DATA: + IMG_SIZE: 224 + MASK_PATCH_SIZE: 32 + MASK_RATIO: 0.6 +TRAIN: + EPOCHS: 800 + WARMUP_EPOCHS: 10 + BASE_LR: 1e-4 + WARMUP_LR: 5e-7 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 100 +SAVE_FREQ: 5 +TAG: simmim_pretrain__vit_base__img224__800ep diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..9308bd171920a65673829f624580b643fda8dd6a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/configs/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,185 @@ +_base_ = ('../YOLO-World/mmyolo/configs/yolov8/' + 'yolov8_x_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' + +# scaling model from X to XL +deepen_factor = 1.0 +widen_factor = 1.5 + +backbone = _base_.model.backbone +backbone.update( + deepen_factor=deepen_factor, + widen_factor=widen_factor +) + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model=backbone, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + widen_factor=widen_factor, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +# train_pipeline = [ +# *_base_.pre_transform, +# dict(type='MultiModalMosaic', +# img_scale=_base_.img_scale, +# pad_val=114.0, +# pre_transform=_base_.pre_transform), +# dict( +# type='YOLOv5RandomAffine', +# max_rotate_degree=0.0, +# max_shear_degree=0.0, +# scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), +# max_aspect_ratio=_base_.max_aspect_ratio, +# border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), +# border_val=(114, 114, 114)), +# *_base_.last_transform[:-1], +# *text_transform, +# ] +# train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +# obj365v1_train_dataset = dict( +# type='MultiModalDataset', +# dataset=dict( +# type='YOLOv5Objects365V1Dataset', +# data_root='data/objects365v1/', +# ann_file='annotations/objects365_train.json', +# data_prefix=dict(img='train/'), +# filter_cfg=dict(filter_empty_gt=False, min_size=32)), +# class_text_path='data/texts/obj365v1_class_texts.json', +# pipeline=train_pipeline) + +# mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', +# data_root='data/mixed_grounding/', +# ann_file='annotations/final_mixed_train_no_coco.json', +# data_prefix=dict(img='gqa/images/'), +# filter_cfg=dict(filter_empty_gt=False, min_size=32), +# pipeline=train_pipeline) + +# flickr_train_dataset = dict( +# type='YOLOv5MixedGroundingDataset', +# data_root='data/flickr/', +# ann_file='annotations/final_flickr_separateGT_train.json', +# data_prefix=dict(img='full_images/'), +# filter_cfg=dict(filter_empty_gt=True, min_size=32), +# pipeline=train_pipeline) + +# train_dataloader = dict(batch_size=train_batch_size_per_gpu, +# collate_fn=dict(type='yolow_collate'), +# dataset=dict(_delete_=True, +# type='ConcatDataset', +# datasets=[ +# obj365v1_train_dataset, +# flickr_train_dataset, mg_train_dataset +# ], +# ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +# val_evaluator = dict(type='mmdet.LVISMetric', +# ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', +# metric='bbox') +# test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +# custom_hooks = [ +# dict(type='EMAHook', +# ema_type='ExpMomentumEMA', +# momentum=0.0001, +# update_buffers=True, +# strict_load=False, +# priority=49), +# dict(type='mmdet.PipelineSwitchHook', +# switch_epoch=max_epochs - close_mosaic_epochs, +# switch_pipeline=train_pipeline_stage2) +# ] +# train_cfg = dict(max_epochs=max_epochs, +# val_interval=10, +# dynamic_intervals=[((max_epochs - close_mosaic_epochs), +# _base_.val_interval_stage2)]) +# optim_wrapper = dict(optimizer=dict( +# _delete_=True, +# type='AdamW', +# lr=base_lr, +# weight_decay=weight_decay, +# batch_size_per_gpu=train_batch_size_per_gpu), +# paramwise_cfg=dict(bias_decay_mult=0.0, +# norm_decay_mult=0.0, +# custom_keys={ +# 'backbone.text_model': +# dict(lr_mult=0.01), +# 'logit_scale': +# dict(weight_decay=0.0) +# }), +# constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95e540099ae2829a4580e84c069d021035afad9d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/__init__.py @@ -0,0 +1,8 @@ +from .data_simmim import build_loader_simmim +from .data_finetune import build_loader_finetune + +def build_loader(config, logger, is_pretrain): + if is_pretrain: + return build_loader_simmim(config, logger) + else: + return build_loader_finetune(config, logger) \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/data_finetune.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/data_finetune.py new file mode 100644 index 0000000000000000000000000000000000000000..a8be62f12058775fe3091f6369ee72b29abd637f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/data_finetune.py @@ -0,0 +1,140 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Zhenda Xie +# -------------------------------------------------------- + +import os +import torch.distributed as dist +from torch.utils.data import DataLoader, DistributedSampler +from torchvision import datasets, transforms +from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD +from timm.data import Mixup +from timm.data import create_transform +from timm.data.transforms import _pil_interp +from PIL import Image +import json +import torch + + +def build_loader_finetune(config, logger): + config.defrost() + dataset_train, config.MODEL.NUM_CLASSES = build_dataset(is_train=True, config=config, logger=logger) + config.freeze() + dataset_val, _ = build_dataset(is_train=False, config=config, logger=logger) + logger.info(f"Build dataset: train images = {len(dataset_train)}, val images = {len(dataset_val)}") + + num_tasks = dist.get_world_size() + global_rank = dist.get_rank() + sampler_train = DistributedSampler( + dataset_train, num_replicas=num_tasks, rank=global_rank, shuffle=True + ) + sampler_val = DistributedSampler( + dataset_val, num_replicas=num_tasks, rank=global_rank, shuffle=False + ) + + data_loader_train = DataLoader( + dataset_train, sampler=sampler_train, + batch_size=config.DATA.BATCH_SIZE, + num_workers=config.DATA.NUM_WORKERS, + pin_memory=config.DATA.PIN_MEMORY, + drop_last=True, + ) + + data_loader_val = DataLoader( + dataset_val, sampler=sampler_val, + batch_size=config.DATA.BATCH_SIZE, + num_workers=config.DATA.NUM_WORKERS, + pin_memory=config.DATA.PIN_MEMORY, + drop_last=False, + ) + + # setup mixup / cutmix + mixup_fn = None + mixup_active = config.AUG.MIXUP > 0 or config.AUG.CUTMIX > 0. or config.AUG.CUTMIX_MINMAX is not None + if mixup_active: + mixup_fn = Mixup( + mixup_alpha=config.AUG.MIXUP, cutmix_alpha=config.AUG.CUTMIX, cutmix_minmax=config.AUG.CUTMIX_MINMAX, + prob=config.AUG.MIXUP_PROB, switch_prob=config.AUG.MIXUP_SWITCH_PROB, mode=config.AUG.MIXUP_MODE, + label_smoothing=config.MODEL.LABEL_SMOOTHING, num_classes=config.MODEL.NUM_CLASSES) + + return dataset_train, dataset_val, data_loader_train, data_loader_val, mixup_fn + + +class binary_dataset(torch.utils.data.Dataset): + def __init__(self, data_jsonl, transform=None): + self.data = [] + with open(data_jsonl, 'r') as f: + for line in f.readlines(): + self.data.append(json.loads(line)) + self.transform = transform + + def __len__(self): + return len(self.data) + + def __getitem__(self, idx): + path, label, score = self.data[idx] + img = Image.open(os.path.join("VBench-2.0_human_anomaly/dataset/all_images", path)) + if self.transform: + img = self.transform(img) + return img, label + + + + +def build_dataset(is_train, config, logger): + transform = build_transform(is_train, config) + logger.info(f'Fine-tune data transform, is_train={is_train}:\n{transform}') + + # if config.DATA.DATASET == 'imagenet': + # prefix = 'train' if is_train else 'val' + # root = os.path.join(config.DATA.DATA_PATH, prefix) + # dataset = datasets.ImageFolder(root, transform=transform) + # nb_classes = 1000 + + data_jsonl = config.DATA.TRAIN_PATH if is_train else config.DATA.VAL_PATH + dataset = binary_dataset(data_jsonl, transform=transform) + nb_classes = 2 + + return dataset, nb_classes + + +def build_transform(is_train, config): + resize_im = config.DATA.IMG_SIZE > 32 + if is_train: + # this should always dispatch to transforms_imagenet_train + transform = create_transform( + input_size=config.DATA.IMG_SIZE, + is_training=True, + color_jitter=config.AUG.COLOR_JITTER if config.AUG.COLOR_JITTER > 0 else None, + auto_augment=config.AUG.AUTO_AUGMENT if config.AUG.AUTO_AUGMENT != 'none' else None, + re_prob=config.AUG.REPROB, + re_mode=config.AUG.REMODE, + re_count=config.AUG.RECOUNT, + interpolation=config.DATA.INTERPOLATION, + ) + if not resize_im: + # replace RandomResizedCropAndInterpolation with + # RandomCrop + transform.transforms[0] = transforms.RandomCrop(config.DATA.IMG_SIZE, padding=4) + return transform + + t = [] + if resize_im: + if config.TEST.CROP: + size = int((256 / 224) * config.DATA.IMG_SIZE) + t.append( + transforms.Resize(size, interpolation=_pil_interp(config.DATA.INTERPOLATION)), + # to maintain same ratio w.r.t. 224 images + ) + t.append(transforms.CenterCrop(config.DATA.IMG_SIZE)) + else: + t.append( + transforms.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE), + interpolation=_pil_interp(config.DATA.INTERPOLATION)) + ) + + t.append(transforms.ToTensor()) + t.append(transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD)) + return transforms.Compose(t) \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/data_simmim.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/data_simmim.py new file mode 100644 index 0000000000000000000000000000000000000000..89f468f42641e75cbcd01d51c55fd3d5efda7313 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/data_simmim.py @@ -0,0 +1,104 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Zhenda Xie +# -------------------------------------------------------- + +import math +import random +import numpy as np + +import torch +import torch.distributed as dist +import torchvision.transforms as T +from torch.utils.data import DataLoader, DistributedSampler +from torch.utils.data._utils.collate import default_collate +from torchvision.datasets import ImageFolder +from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD + + +class MaskGenerator: + def __init__(self, input_size=192, mask_patch_size=32, model_patch_size=4, mask_ratio=0.6): + self.input_size = input_size + self.mask_patch_size = mask_patch_size + self.model_patch_size = model_patch_size + self.mask_ratio = mask_ratio + + assert self.input_size % self.mask_patch_size == 0 + assert self.mask_patch_size % self.model_patch_size == 0 + + self.rand_size = self.input_size // self.mask_patch_size + self.scale = self.mask_patch_size // self.model_patch_size + + self.token_count = self.rand_size ** 2 + self.mask_count = int(np.ceil(self.token_count * self.mask_ratio)) + + def __call__(self): + mask_idx = np.random.permutation(self.token_count)[:self.mask_count] + mask = np.zeros(self.token_count, dtype=int) + mask[mask_idx] = 1 + + mask = mask.reshape((self.rand_size, self.rand_size)) + mask = mask.repeat(self.scale, axis=0).repeat(self.scale, axis=1) + + return mask + + +class SimMIMTransform: + def __init__(self, config): + self.transform_img = T.Compose([ + T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img), + T.RandomResizedCrop(config.DATA.IMG_SIZE, scale=(0.67, 1.), ratio=(3. / 4., 4. / 3.)), + T.RandomHorizontalFlip(), + T.ToTensor(), + T.Normalize(mean=torch.tensor(IMAGENET_DEFAULT_MEAN),std=torch.tensor(IMAGENET_DEFAULT_STD)), + ]) + + if config.MODEL.TYPE == 'swin': + model_patch_size=config.MODEL.SWIN.PATCH_SIZE + elif config.MODEL.TYPE == 'vit': + model_patch_size=config.MODEL.VIT.PATCH_SIZE + else: + raise NotImplementedError + + self.mask_generator = MaskGenerator( + input_size=config.DATA.IMG_SIZE, + mask_patch_size=config.DATA.MASK_PATCH_SIZE, + model_patch_size=model_patch_size, + mask_ratio=config.DATA.MASK_RATIO, + ) + + def __call__(self, img): + img = self.transform_img(img) + mask = self.mask_generator() + + return img, mask + + +def collate_fn(batch): + if not isinstance(batch[0][0], tuple): + return default_collate(batch) + else: + batch_num = len(batch) + ret = [] + for item_idx in range(len(batch[0][0])): + if batch[0][0][item_idx] is None: + ret.append(None) + else: + ret.append(default_collate([batch[i][0][item_idx] for i in range(batch_num)])) + ret.append(default_collate([batch[i][1] for i in range(batch_num)])) + return ret + + +def build_loader_simmim(config, logger): + transform = SimMIMTransform(config) + logger.info(f'Pre-train data transform:\n{transform}') + + dataset = ImageFolder(config.DATA.DATA_PATH, transform) + logger.info(f'Build dataset: train images = {len(dataset)}') + + sampler = DistributedSampler(dataset, num_replicas=dist.get_world_size(), rank=dist.get_rank(), shuffle=True) + dataloader = DataLoader(dataset, config.DATA.BATCH_SIZE, sampler=sampler, num_workers=config.DATA.NUM_WORKERS, pin_memory=True, drop_last=True, collate_fn=collate_fn) + + return dataloader \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/lvis/annotations/lvis_v1_minival_inserted_image_name.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/lvis/annotations/lvis_v1_minival_inserted_image_name.json new file mode 100644 index 0000000000000000000000000000000000000000..6bd2c04ec085318789058f787969998cafe4976d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/lvis/annotations/lvis_v1_minival_inserted_image_name.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02301f6ccd89d1ee3d35112cb57d000c3396f34e4073066c90b2c1fbf47b55ce +size 35463626 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/coco_class_texts.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/coco_class_texts.json new file mode 100644 index 0000000000000000000000000000000000000000..b83ee71a04c5d2606793ea9e271a8422ca762ed5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/coco_class_texts.json @@ -0,0 +1 @@ +[["person"], ["bicycle"], ["car"], ["motorcycle"], ["airplane"], ["bus"], ["train"], ["truck"], ["boat"], ["traffic light"], ["fire hydrant"], ["stop sign"], ["parking meter"], ["bench"], ["bird"], ["cat"], ["dog"], ["horse"], ["sheep"], ["cow"], ["elephant"], ["bear"], ["zebra"], ["giraffe"], ["backpack"], ["umbrella"], ["handbag"], ["tie"], ["suitcase"], ["frisbee"], ["skis"], ["snowboard"], ["sports ball"], ["kite"], ["baseball bat"], ["baseball glove"], ["skateboard"], ["surfboard"], ["tennis racket"], ["bottle"], ["wine glass"], ["cup"], ["fork"], ["knife"], ["spoon"], ["bowl"], ["banana"], ["apple"], ["sandwich"], ["orange"], ["broccoli"], ["carrot"], ["hot dog"], ["pizza"], ["donut"], ["cake"], ["chair"], ["couch"], ["potted plant"], ["bed"], ["dining table"], ["toilet"], ["tv"], ["laptop"], ["mouse"], ["remote"], ["keyboard"], ["cell phone"], ["microwave"], ["oven"], ["toaster"], ["sink"], ["refrigerator"], ["book"], ["clock"], ["vase"], ["scissors"], ["teddy bear"], ["hair drier"], ["toothbrush"]] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/lvis_v1_base_class_captions.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/lvis_v1_base_class_captions.json new file mode 100644 index 0000000000000000000000000000000000000000..27e5e72636076fccdbbe7a93ffb56d2d8bbe0a3f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/lvis_v1_base_class_captions.json @@ -0,0 +1 @@ +[["aerosol can", "spray can"], ["air conditioner"], ["airplane", "aeroplane"], ["alarm clock"], ["alcohol", "alcoholic beverage"], ["alligator", "gator"], ["almond"], ["ambulance"], ["amplifier"], ["anklet", "ankle bracelet"], ["antenna", "aerial", "transmitting aerial"], ["apple"], ["apron"], ["aquarium", "fish tank"], ["armband"], ["armchair"], ["artichoke"], ["trash can", "garbage can", "wastebin", "dustbin", "trash barrel", "trash bin"], ["ashtray"], ["asparagus"], ["atomizer", "atomiser", "spray", "sprayer", "nebulizer", "nebuliser"], ["avocado"], ["award", "accolade"], ["awning"], ["baby buggy", "baby carriage", "perambulator", "pram", "stroller"], ["basketball backboard"], ["backpack", "knapsack", "packsack", "rucksack", "haversack"], ["handbag", "purse", "pocketbook"], ["suitcase", "baggage", "luggage"], ["bagel", "beigel"], ["ball"], ["balloon"], ["bamboo"], ["banana"], ["Band Aid"], ["bandage"], ["bandanna", "bandana"], ["banner", "streamer"], ["barrel", "cask"], ["barrette"], ["barrow", "garden cart", "lawn cart", "wheelbarrow"], ["baseball base"], ["baseball"], ["baseball bat"], ["baseball cap", "jockey cap", "golf cap"], ["baseball glove", "baseball mitt"], ["basket", "handbasket"], ["basketball"], ["bat", "bat animal"], ["bath mat"], ["bath towel"], ["bathrobe"], ["bathtub", "bathing tub"], ["battery"], ["bead"], ["bean curd", "tofu"], ["beanbag"], ["beanie", "beany"], ["bear"], ["bed"], ["bedspread", "bedcover", "bed covering", "counterpane", "spread"], ["cow"], ["beef", "beef food", "boeuf", "boeuf food"], ["beer bottle"], ["beer can"], ["bell"], ["bell pepper", "capsicum"], ["belt"], ["belt buckle"], ["bench"], ["beret"], ["bib"], ["bicycle", "bike", "bike bicycle"], ["visor", "vizor"], ["billboard"], ["binder", "ring-binder"], ["binoculars", "field glasses", "opera glasses"], ["bird"], ["birdfeeder"], ["birdbath"], ["birdcage"], ["birdhouse"], ["birthday cake"], ["black sheep"], ["blackberry"], ["blackboard", "chalkboard"], ["blanket"], ["blazer", "sport jacket", "sport coat", "sports jacket", "sports coat"], ["blender", "liquidizer", "liquidiser"], ["blinker", "flasher"], ["blouse"], ["blueberry"], ["boat", "ship", "ship boat"], ["bobbin", "spool", "reel"], ["bobby pin", "hairgrip"], ["boiled egg", "coddled egg"], ["deadbolt"], ["bolt"], ["book"], ["bookcase"], ["booklet", "brochure", "leaflet", "pamphlet"], ["boot"], ["bottle"], ["bottle opener"], ["bouquet"], ["bow", "bow decorative ribbons"], ["bow-tie", "bowtie"], ["bowl"], ["bowler hat", "bowler", "derby hat", "derby", "plug hat"], ["box"], ["suspenders"], ["bracelet", "bangle"], ["brassiere", "bra", "bandeau"], ["bread-bin", "breadbox"], ["bread"], ["bridal gown", "wedding gown", "wedding dress"], ["briefcase"], ["broccoli"], ["broom"], ["brownie"], ["brussels sprouts"], ["bucket", "pail"], ["horned cow"], ["bulldog"], ["bullet train"], ["bulletin board", "notice board"], ["bullhorn", "megaphone"], ["bun", "roll"], ["bunk bed"], ["buoy"], ["bus", "bus vehicle", "autobus", "charabanc", "double-decker", "motorbus", "motorcoach"], ["business card"], ["butter"], ["butterfly"], ["button"], ["cab", "cab taxi", "taxi", "taxicab"], ["cabin car", "caboose"], ["cabinet"], ["cake"], ["calculator"], ["calendar"], ["calf"], ["camcorder"], ["camel"], ["camera"], ["camera lens"], ["camper", "camper vehicle", "camping bus", "motor home"], ["can", "tin can"], ["can opener", "tin opener"], ["candle", "candlestick"], ["candle holder"], ["candy cane"], ["walking cane"], ["canister", "cannister"], ["canoe"], ["cantaloup", "cantaloupe"], ["cap", "cap headwear"], ["bottle cap", "cap", "cap container lid"], ["cape"], ["cappuccino", "coffee cappuccino"], ["car", "car automobile", "auto", "auto automobile", "automobile"], ["railcar", "railcar part of a train", "railway car", "railway car part of a train", "railroad car", "railroad car part of a train"], ["identity card"], ["card"], ["cardigan"], ["horse carriage"], ["carrot"], ["tote bag"], ["cart"], ["carton"], ["cash register", "register", "register for cash transactions"], ["cast", "plaster cast", "plaster bandage"], ["cat"], ["cauliflower"], ["cayenne", "cayenne spice", "cayenne pepper", "cayenne pepper spice", "red pepper", "red pepper spice"], ["CD player"], ["celery"], ["cellular telephone", "cellular phone", "cellphone", "mobile phone", "smart phone"], ["chair"], ["chandelier"], ["cherry"], ["chicken", "chicken animal"], ["chickpea", "garbanzo"], ["chili", "chili vegetable", "chili pepper", "chili pepper vegetable", "chilli", "chilli vegetable", "chilly", "chilly vegetable", "chile", "chile vegetable"], ["crisp", "crisp potato chip", "potato chip"], ["chocolate bar"], ["chocolate cake"], ["choker", "collar", "neckband"], ["chopping board", "cutting board", "chopping block"], ["chopstick"], ["Christmas tree"], ["slide"], ["cigarette"], ["cigarette case", "cigarette pack"], ["cistern", "water tank"], ["clasp"], ["cleansing agent", "cleanser", "cleaner"], ["clip"], ["clipboard"], ["clock", "timepiece", "timekeeper"], ["clock tower"], ["clothes hamper", "laundry basket", "clothes basket"], ["clothespin", "clothes peg"], ["coaster"], ["coat"], ["coat hanger", "clothes hanger", "dress hanger"], ["coatrack", "hatrack"], ["cock", "rooster"], ["coconut", "cocoanut"], ["coffee maker", "coffee machine"], ["coffee table", "cocktail table"], ["coffeepot"], ["coin"], ["colander", "cullender"], ["coleslaw", "slaw"], ["pacifier", "teething ring"], ["computer keyboard", "keyboard", "keyboard computer"], ["condiment"], ["cone", "traffic cone"], ["control", "controller"], ["cookie", "cooky", "biscuit", "biscuit cookie"], ["cooler", "cooler for food", "ice chest"], ["cork", "cork bottle plug", "bottle cork"], ["corkscrew", "bottle screw"], ["edible corn", "corn", "maize"], ["cornet", "horn", "trumpet"], ["cornice", "valance", "valance board", "pelmet"], ["corset", "girdle"], ["costume"], ["cowbell"], ["cowboy hat", "ten-gallon hat"], ["crab", "crab animal"], ["cracker"], ["crate"], ["crayon", "wax crayon"], ["crescent roll", "croissant"], ["crib", "cot"], ["crock pot", "earthenware jar"], ["crossbar"], ["crow"], ["crown"], ["crucifix"], ["cruise ship", "cruise liner"], ["police cruiser", "patrol car", "police car", "squad car"], ["crumb"], ["crutch"], ["cub", "cub animal"], ["cube", "square block"], ["cucumber", "cuke"], ["cufflink"], ["cup"], ["trophy cup"], ["cupboard", "closet"], ["cupcake"], ["curtain", "drapery"], ["cushion"], ["dartboard"], ["deck chair", "beach chair"], ["deer", "cervid"], ["dental floss", "floss"], ["desk"], ["diaper"], ["dining table"], ["dish"], ["dish antenna"], ["dishrag", "dishcloth"], ["dishtowel", "tea towel"], ["dishwasher", "dishwashing machine"], ["dispenser"], ["Dixie cup", "paper cup"], ["dog"], ["dog collar"], ["doll"], ["dolphin"], ["domestic ass", "donkey"], ["doorknob", "doorhandle"], ["doormat", "welcome mat"], ["doughnut", "donut"], ["drawer"], ["underdrawers", "boxers", "boxershorts"], ["dress", "frock"], ["dress hat", "high hat", "opera hat", "silk hat", "top hat"], ["dress suit"], ["dresser"], ["drill"], ["drum", "drum musical instrument"], ["duck"], ["duckling"], ["duct tape"], ["duffel bag", "duffle bag", "duffel", "duffle"], ["dumpster"], ["eagle"], ["earphone", "earpiece", "headphone"], ["earring"], ["easel"], ["egg", "eggs"], ["egg yolk", "yolk", "yolk egg"], ["eggbeater", "eggwhisk"], ["eggplant", "aubergine"], ["refrigerator"], ["elephant"], ["elk", "moose"], ["envelope"], ["eraser"], ["fan"], ["faucet", "spigot", "tap"], ["Ferris wheel"], ["ferry", "ferryboat"], ["fighter jet", "fighter aircraft", "attack aircraft"], ["figurine"], ["file cabinet", "filing cabinet"], ["fire alarm", "smoke alarm"], ["fire engine", "fire truck"], ["fire extinguisher", "extinguisher"], ["fire hose"], ["fireplace"], ["fireplug", "fire hydrant", "hydrant"], ["fish"], ["fish", "fish food"], ["fishing rod", "fishing pole"], ["flag"], ["flagpole", "flagstaff"], ["flamingo"], ["flannel"], ["flap"], ["flashlight", "torch"], ["flip-flop", "flip-flop sandal"], ["flipper", "flipper footwear", "fin", "fin footwear"], ["flower arrangement", "floral arrangement"], ["flute glass", "champagne flute"], ["foal"], ["folding chair"], ["food processor"], ["football", "football American"], ["footstool", "footrest"], ["fork"], ["forklift"], ["freight car"], ["French toast"], ["freshener", "air freshener"], ["frisbee"], ["frog", "toad", "toad frog"], ["fruit juice"], ["frying pan", "frypan", "skillet"], ["garbage truck"], ["garden hose"], ["gargle", "mouthwash"], ["garlic", "ail"], ["gazelle"], ["gelatin", "jelly"], ["giant panda", "panda", "panda bear"], ["gift wrap"], ["ginger", "gingerroot"], ["giraffe"], ["cincture", "sash", "waistband", "waistcloth"], ["glass", "glass drink container", "drinking glass"], ["globe"], ["glove"], ["goat"], ["goggles"], ["golf club", "golf-club"], ["golfcart"], ["goose"], ["grape"], ["grater"], ["gravestone", "headstone", "tombstone"], ["green bean"], ["green onion", "spring onion", "scallion"], ["grill", "grille", "grillwork", "radiator grille"], ["grizzly", "grizzly bear"], ["grocery bag"], ["guitar"], ["gull", "seagull"], ["gun"], ["hairbrush"], ["hairnet"], ["hairpin"], ["ham", "jambon", "gammon"], ["hamburger", "beefburger", "burger"], ["hammer"], ["hammock"], ["hamster"], ["hair dryer"], ["hand towel", "face towel"], ["handcart", "pushcart", "hand truck"], ["handkerchief"], ["handle", "grip", "handgrip"], ["hat"], ["veil"], ["headband"], ["headboard"], ["headlight", "headlamp"], ["headscarf"], ["headstall", "headstall for horses", "headpiece", "headpiece for horses"], ["heart"], ["heater", "warmer"], ["helicopter"], ["helmet"], ["highchair", "feeding chair"], ["hinge"], ["hog", "pig"], ["home plate", "home plate baseball", "home base", "home base baseball"], ["honey"], ["fume hood", "exhaust hood"], ["hook"], ["horse"], ["hose", "hosepipe"], ["hot sauce"], ["hummingbird"], ["polar bear"], ["icecream"], ["ice maker"], ["igniter", "ignitor", "lighter"], ["iPod"], ["iron", "iron for clothing", "smoothing iron", "smoothing iron for clothing"], ["ironing board"], ["jacket"], ["jam"], ["jar"], ["jean", "blue jean", "denim"], ["jeep", "landrover"], ["jersey", "T-shirt", "tee shirt"], ["jet plane", "jet-propelled plane"], ["jewelry", "jewellery"], ["jumpsuit"], ["kayak"], ["kettle", "boiler"], ["key"], ["kilt"], ["kimono"], ["kitchen sink"], ["kite"], ["kitten", "kitty"], ["kiwi fruit"], ["knee pad"], ["knife"], ["knob"], ["ladder"], ["ladle"], ["ladybug", "ladybeetle", "ladybird beetle"], ["lamb", "lamb animal"], ["lamp"], ["lamppost"], ["lampshade"], ["lantern"], ["lanyard", "laniard"], ["laptop computer", "notebook computer"], ["latch"], ["legging", "legging clothing", "leging", "leging clothing", "leg covering"], ["Lego", "Lego set"], ["lemon"], ["lettuce"], ["license plate", "numberplate"], ["life buoy", "lifesaver", "life belt", "life ring"], ["life jacket", "life vest"], ["lightbulb"], ["lime"], ["lion"], ["lip balm"], ["lizard"], ["log"], ["lollipop"], ["speaker", "speaker stereo equipment"], ["loveseat"], ["magazine"], ["magnet"], ["mail slot"], ["mailbox", "mailbox at home", "letter box", "letter box at home"], ["mandarin orange"], ["manger", "trough"], ["manhole"], ["map"], ["marker"], ["mashed potato"], ["mask", "facemask"], ["mast"], ["mat", "mat gym equipment", "gym mat"], ["mattress"], ["measuring cup"], ["measuring stick", "ruler", "ruler measuring stick", "measuring rod"], ["meatball"], ["medicine"], ["melon"], ["microphone"], ["microwave oven"], ["milk"], ["minivan"], ["mirror"], ["mitten"], ["mixer", "mixer kitchen tool", "stand mixer"], ["money"], ["monitor", "monitor computer equipment"], ["monkey"], ["motor"], ["motor scooter", "scooter"], ["motorcycle"], ["mound", "mound baseball", "pitcher's mound"], ["mouse", "mouse computer equipment", "computer mouse"], ["mousepad"], ["muffin"], ["mug"], ["mushroom"], ["musical instrument", "instrument", "instrument musical"], ["napkin", "table napkin", "serviette"], ["necklace"], ["necktie", "tie", "tie necktie"], ["needle"], ["nest"], ["newspaper", "paper", "paper newspaper"], ["newsstand"], ["nightshirt", "nightwear", "sleepwear", "nightclothes"], ["noseband", "noseband for animals", "nosepiece", "nosepiece for animals"], ["notebook"], ["notepad"], ["nut"], ["oar"], ["oil lamp", "kerosene lamp", "kerosine lamp"], ["olive oil"], ["onion"], ["orange", "orange fruit"], ["orange juice"], ["ostrich"], ["ottoman", "pouf", "pouffe", "hassock"], ["oven"], ["overalls", "overalls clothing"], ["owl"], ["packet"], ["pad"], ["paddle", "boat paddle"], ["padlock"], ["paintbrush"], ["painting"], ["pajamas", "pyjamas"], ["palette", "pallet"], ["pan", "pan for cooking", "cooking pan"], ["pancake"], ["paper plate"], ["paper towel"], ["parachute"], ["parakeet", "parrakeet", "parroket", "paraquet", "paroquet", "parroquet"], ["parasail", "parasail sports"], ["parasol", "sunshade"], ["parka", "anorak"], ["parking meter"], ["parrot"], ["passenger car", "passenger car part of a train", "coach", "coach part of a train"], ["passport"], ["pastry"], ["pea", "pea food"], ["peach"], ["peanut butter"], ["pear"], ["peeler", "peeler tool for fruit and vegetables"], ["pelican"], ["pen"], ["pencil"], ["penguin"], ["pepper", "peppercorn"], ["pepper mill", "pepper grinder"], ["perfume"], ["person", "baby", "child", "boy", "girl", "man", "woman", "human"], ["pet"], ["pew", "pew church bench", "church bench"], ["phonograph record", "phonograph recording", "record", "record phonograph recording"], ["piano"], ["pickle"], ["pickup truck"], ["pie"], ["pigeon"], ["pillow"], ["pineapple"], ["pinecone"], ["pipe", "piping"], ["pita", "pita bread", "pocket bread"], ["pitcher", "pitcher vessel for liquid", "ewer"], ["pizza"], ["place mat"], ["plate"], ["platter"], ["pliers", "plyers"], ["pocketknife"], ["poker", "poker fire stirring tool", "stove poker", "fire hook"], ["pole", "post"], ["polo shirt", "sport shirt"], ["pony"], ["pop", "pop soda", "soda", "soda pop", "tonic", "soft drink"], ["postbox", "postbox public", "mailbox", "mailbox public"], ["postcard", "postal card", "mailing-card"], ["poster", "placard"], ["pot"], ["flowerpot"], ["potato"], ["potholder"], ["pottery", "clayware"], ["pouch"], ["power shovel", "excavator", "digger"], ["prawn", "shrimp"], ["pretzel"], ["printer", "printing machine"], ["projectile", "projectile weapon", "missile"], ["projector"], ["propeller", "propellor"], ["pumpkin"], ["puppy"], ["quilt", "comforter"], ["rabbit"], ["racket", "racquet"], ["radiator"], ["radio receiver", "radio set", "radio", "tuner", "tuner radio"], ["radish", "daikon"], ["raft"], ["raincoat", "waterproof jacket"], ["ram", "ram animal"], ["raspberry"], ["razorblade"], ["reamer", "reamer juicer", "juicer", "juice reamer"], ["rearview mirror"], ["receipt"], ["recliner", "reclining chair", "lounger", "lounger chair"], ["record player", "phonograph", "phonograph record player", "turntable"], ["reflector"], ["remote control"], ["rhinoceros"], ["rifle"], ["ring"], ["robe"], ["rocking chair"], ["rolling pin"], ["router", "router computer equipment"], ["rubber band", "elastic band"], ["runner", "runner carpet"], ["plastic bag", "paper bag"], ["saddle", "saddle on an animal"], ["saddle blanket", "saddlecloth", "horse blanket"], ["saddlebag"], ["sail"], ["salad"], ["salami"], ["salmon", "salmon fish"], ["salsa"], ["saltshaker"], ["sandal", "sandal type of shoe"], ["sandwich"], ["saucer"], ["sausage"], ["scale", "scale measuring instrument"], ["scarf"], ["school bus"], ["scissors"], ["scoreboard"], ["screwdriver"], ["scrubbing brush"], ["sculpture"], ["seabird", "seafowl"], ["seahorse"], ["seashell"], ["sewing machine"], ["shaker"], ["shampoo"], ["shark"], ["shaving cream", "shaving soap"], ["sheep"], ["shield"], ["shirt"], ["shoe", "sneaker", "sneaker type of shoe", "tennis shoe"], ["shopping bag"], ["shopping cart"], ["short pants", "shorts", "shorts clothing", "trunks", "trunks clothing"], ["shoulder bag"], ["shovel"], ["shower head"], ["shower curtain"], ["signboard"], ["silo"], ["sink"], ["skateboard"], ["skewer"], ["ski"], ["ski boot"], ["ski parka", "ski jacket"], ["ski pole"], ["skirt"], ["sled", "sledge", "sleigh"], ["sleeping bag"], ["slipper", "slipper footwear", "carpet slipper", "carpet slipper footwear"], ["snowboard"], ["snowman"], ["snowmobile"], ["soap"], ["soccer ball"], ["sock"], ["sofa", "couch", "lounge"], ["solar array", "solar battery", "solar panel"], ["soup"], ["soupspoon"], ["sour cream", "soured cream"], ["spatula"], ["spectacles", "specs", "eyeglasses", "glasses"], ["spice rack"], ["spider"], ["sponge"], ["spoon"], ["sportswear", "athletic wear", "activewear"], ["spotlight"], ["squirrel"], ["stapler", "stapler stapling machine"], ["starfish", "sea star"], ["statue", "statue sculpture"], ["steak", "steak food"], ["steering wheel"], ["step stool"], ["stereo", "stereo sound system"], ["stirrup"], ["stool"], ["stop sign"], ["brake light"], ["stove", "kitchen stove", "range", "range kitchen appliance", "kitchen range", "cooking stove"], ["strainer"], ["strap"], ["straw", "straw for drinking", "drinking straw"], ["strawberry"], ["street sign"], ["streetlight", "street lamp"], ["suit", "suit clothing"], ["sunflower"], ["sunglasses"], ["sunhat"], ["surfboard"], ["sushi"], ["mop"], ["sweat pants"], ["sweatband"], ["sweater"], ["sweatshirt"], ["sweet potato"], ["swimsuit", "swimwear", "bathing suit", "swimming costume", "bathing costume", "swimming trunks", "bathing trunks"], ["sword"], ["table"], ["table lamp"], ["tablecloth"], ["tag"], ["taillight", "rear light"], ["tank", "tank storage vessel", "storage tank"], ["tank top", "tank top clothing"], ["tape", "tape sticky cloth or paper"], ["tape measure", "measuring tape"], ["tapestry"], ["tarp"], ["tartan", "plaid"], ["tassel"], ["tea bag"], ["teacup"], ["teakettle"], ["teapot"], ["teddy bear"], ["telephone", "phone", "telephone set"], ["telephone booth", "phone booth", "call box", "telephone box", "telephone kiosk"], ["telephone pole", "telegraph pole", "telegraph post"], ["television camera", "tv camera"], ["television set", "tv", "tv set"], ["tennis ball"], ["tennis racket"], ["thermometer"], ["thermos bottle"], ["thermostat"], ["thread", "yarn"], ["thumbtack", "drawing pin", "pushpin"], ["tiara"], ["tiger"], ["tights", "tights clothing", "leotards"], ["timer", "stopwatch"], ["tinfoil"], ["tinsel"], ["tissue paper"], ["toast", "toast food"], ["toaster"], ["toaster oven"], ["toilet"], ["toilet tissue", "toilet paper", "bathroom tissue"], ["tomato"], ["tongs"], ["toolbox"], ["toothbrush"], ["toothpaste"], ["toothpick"], ["cover"], ["tortilla"], ["tow truck"], ["towel"], ["towel rack", "towel rail", "towel bar"], ["toy"], ["tractor", "tractor farm equipment"], ["traffic light"], ["dirt bike"], ["trailer truck", "tractor trailer", "trucking rig", "articulated lorry", "semi truck"], ["train", "train railroad vehicle", "railroad train"], ["tray"], ["tricycle"], ["tripod"], ["trousers", "pants", "pants clothing"], ["truck"], ["trunk"], ["turban"], ["turkey", "turkey food"], ["turtle"], ["turtleneck", "turtleneck clothing", "polo-neck"], ["typewriter"], ["umbrella"], ["underwear", "underclothes", "underclothing", "underpants"], ["urinal"], ["urn"], ["vacuum cleaner"], ["vase"], ["vending machine"], ["vent", "blowhole", "air vent"], ["vest", "waistcoat"], ["videotape"], ["volleyball"], ["waffle"], ["wagon"], ["wagon wheel"], ["walking stick"], ["wall clock"], ["wall socket", "wall plug", "electric outlet", "electrical outlet", "outlet", "electric receptacle"], ["wallet", "billfold"], ["automatic washer", "washing machine"], ["watch", "wristwatch"], ["water bottle"], ["water cooler"], ["water faucet", "water tap", "tap", "tap water faucet"], ["water jug"], ["water scooter", "sea scooter", "jet ski"], ["water ski"], ["water tower"], ["watering can"], ["watermelon"], ["weathervane", "vane", "vane weathervane", "wind vane"], ["webcam"], ["wedding cake", "bridecake"], ["wedding ring", "wedding band"], ["wet suit"], ["wheel"], ["wheelchair"], ["whipped cream"], ["whistle"], ["wig"], ["wind chime"], ["windmill"], ["window box", "window box for plants"], ["windshield wiper", "windscreen wiper", "wiper", "wiper for windshield or screen"], ["windsock", "air sock", "air-sleeve", "wind sleeve", "wind cone"], ["wine bottle"], ["wine bucket", "wine cooler"], ["wineglass"], ["blinder", "blinder for horses"], ["wok"], ["wooden spoon"], ["wreath"], ["wrench", "spanner"], ["wristband"], ["wristlet", "wrist band"], ["yacht"], ["yogurt", "yoghurt", "yoghourt"], ["yoke", "yoke animal equipment"], ["zebra"], ["zucchini", "courgette"]] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/lvis_v1_class_texts.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/lvis_v1_class_texts.json new file mode 100644 index 0000000000000000000000000000000000000000..367aaf5430da14c914503b46e4a91bd1542849dd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/lvis_v1_class_texts.json @@ -0,0 +1 @@ +[["aerosol can", "spray can"], ["air conditioner"], ["airplane", "aeroplane"], ["alarm clock"], ["alcohol", "alcoholic beverage"], ["alligator", "gator"], ["almond"], ["ambulance"], ["amplifier"], ["anklet", "ankle bracelet"], ["antenna", "aerial", "transmitting aerial"], ["apple"], ["applesauce"], ["apricot"], ["apron"], ["aquarium", "fish tank"], ["arctic", "arctic type of shoe", "galosh", "golosh", "rubber", "rubber type of shoe", "gumshoe"], ["armband"], ["armchair"], ["armoire"], ["armor", "armour"], ["artichoke"], ["trash can", "garbage can", "wastebin", "dustbin", "trash barrel", "trash bin"], ["ashtray"], ["asparagus"], ["atomizer", "atomiser", "spray", "sprayer", "nebulizer", "nebuliser"], ["avocado"], ["award", "accolade"], ["awning"], ["ax", "axe"], ["baboon"], ["baby buggy", "baby carriage", "perambulator", "pram", "stroller"], ["basketball backboard"], ["backpack", "knapsack", "packsack", "rucksack", "haversack"], ["handbag", "purse", "pocketbook"], ["suitcase", "baggage", "luggage"], ["bagel", "beigel"], ["bagpipe"], ["baguet", "baguette"], ["bait", "lure"], ["ball"], ["ballet skirt", "tutu"], ["balloon"], ["bamboo"], ["banana"], ["Band Aid"], ["bandage"], ["bandanna", "bandana"], ["banjo"], ["banner", "streamer"], ["barbell"], ["barge"], ["barrel", "cask"], ["barrette"], ["barrow", "garden cart", "lawn cart", "wheelbarrow"], ["baseball base"], ["baseball"], ["baseball bat"], ["baseball cap", "jockey cap", "golf cap"], ["baseball glove", "baseball mitt"], ["basket", "handbasket"], ["basketball"], ["bass horn", "sousaphone", "tuba"], ["bat", "bat animal"], ["bath mat"], ["bath towel"], ["bathrobe"], ["bathtub", "bathing tub"], ["batter", "batter food"], ["battery"], ["beachball"], ["bead"], ["bean curd", "tofu"], ["beanbag"], ["beanie", "beany"], ["bear"], ["bed"], ["bedpan"], ["bedspread", "bedcover", "bed covering", "counterpane", "spread"], ["cow"], ["beef", "beef food", "boeuf", "boeuf food"], ["beeper", "pager"], ["beer bottle"], ["beer can"], ["beetle"], ["bell"], ["bell pepper", "capsicum"], ["belt"], ["belt buckle"], ["bench"], ["beret"], ["bib"], ["Bible"], ["bicycle", "bike", "bike bicycle"], ["visor", "vizor"], ["billboard"], ["binder", "ring-binder"], ["binoculars", "field glasses", "opera glasses"], ["bird"], ["birdfeeder"], ["birdbath"], ["birdcage"], ["birdhouse"], ["birthday cake"], ["birthday card"], ["pirate flag"], ["black sheep"], ["blackberry"], ["blackboard", "chalkboard"], ["blanket"], ["blazer", "sport jacket", "sport coat", "sports jacket", "sports coat"], ["blender", "liquidizer", "liquidiser"], ["blimp"], ["blinker", "flasher"], ["blouse"], ["blueberry"], ["gameboard"], ["boat", "ship", "ship boat"], ["bob", "bobber", "bobfloat"], ["bobbin", "spool", "reel"], ["bobby pin", "hairgrip"], ["boiled egg", "coddled egg"], ["bolo tie", "bolo", "bola tie", "bola"], ["deadbolt"], ["bolt"], ["bonnet"], ["book"], ["bookcase"], ["booklet", "brochure", "leaflet", "pamphlet"], ["bookmark", "bookmarker"], ["boom microphone", "microphone boom"], ["boot"], ["bottle"], ["bottle opener"], ["bouquet"], ["bow", "bow weapon"], ["bow", "bow decorative ribbons"], ["bow-tie", "bowtie"], ["bowl"], ["pipe bowl"], ["bowler hat", "bowler", "derby hat", "derby", "plug hat"], ["bowling ball"], ["box"], ["boxing glove"], ["suspenders"], ["bracelet", "bangle"], ["brass plaque"], ["brassiere", "bra", "bandeau"], ["bread-bin", "breadbox"], ["bread"], ["breechcloth", "breechclout", "loincloth"], ["bridal gown", "wedding gown", "wedding dress"], ["briefcase"], ["broccoli"], ["broach"], ["broom"], ["brownie"], ["brussels sprouts"], ["bubble gum"], ["bucket", "pail"], ["horse buggy"], ["horned cow"], ["bulldog"], ["bulldozer", "dozer"], ["bullet train"], ["bulletin board", "notice board"], ["bulletproof vest"], ["bullhorn", "megaphone"], ["bun", "roll"], ["bunk bed"], ["buoy"], ["burrito"], ["bus", "bus vehicle", "autobus", "charabanc", "double-decker", "motorbus", "motorcoach"], ["business card"], ["butter"], ["butterfly"], ["button"], ["cab", "cab taxi", "taxi", "taxicab"], ["cabana"], ["cabin car", "caboose"], ["cabinet"], ["locker", "storage locker"], ["cake"], ["calculator"], ["calendar"], ["calf"], ["camcorder"], ["camel"], ["camera"], ["camera lens"], ["camper", "camper vehicle", "camping bus", "motor home"], ["can", "tin can"], ["can opener", "tin opener"], ["candle", "candlestick"], ["candle holder"], ["candy bar"], ["candy cane"], ["walking cane"], ["canister", "cannister"], ["canoe"], ["cantaloup", "cantaloupe"], ["canteen"], ["cap", "cap headwear"], ["bottle cap", "cap", "cap container lid"], ["cape"], ["cappuccino", "coffee cappuccino"], ["car", "car automobile", "auto", "auto automobile", "automobile"], ["railcar", "railcar part of a train", "railway car", "railway car part of a train", "railroad car", "railroad car part of a train"], ["elevator car"], ["car battery", "automobile battery"], ["identity card"], ["card"], ["cardigan"], ["cargo ship", "cargo vessel"], ["carnation"], ["horse carriage"], ["carrot"], ["tote bag"], ["cart"], ["carton"], ["cash register", "register", "register for cash transactions"], ["casserole"], ["cassette"], ["cast", "plaster cast", "plaster bandage"], ["cat"], ["cauliflower"], ["cayenne", "cayenne spice", "cayenne pepper", "cayenne pepper spice", "red pepper", "red pepper spice"], ["CD player"], ["celery"], ["cellular telephone", "cellular phone", "cellphone", "mobile phone", "smart phone"], ["chain mail", "ring mail", "chain armor", "chain armour", "ring armor", "ring armour"], ["chair"], ["chaise longue", "chaise", "daybed"], ["chalice"], ["chandelier"], ["chap"], ["checkbook", "chequebook"], ["checkerboard"], ["cherry"], ["chessboard"], ["chicken", "chicken animal"], ["chickpea", "garbanzo"], ["chili", "chili vegetable", "chili pepper", "chili pepper vegetable", "chilli", "chilli vegetable", "chilly", "chilly vegetable", "chile", "chile vegetable"], ["chime", "gong"], ["chinaware"], ["crisp", "crisp potato chip", "potato chip"], ["poker chip"], ["chocolate bar"], ["chocolate cake"], ["chocolate milk"], ["chocolate mousse"], ["choker", "collar", "neckband"], ["chopping board", "cutting board", "chopping block"], ["chopstick"], ["Christmas tree"], ["slide"], ["cider", "cyder"], ["cigar box"], ["cigarette"], ["cigarette case", "cigarette pack"], ["cistern", "water tank"], ["clarinet"], ["clasp"], ["cleansing agent", "cleanser", "cleaner"], ["cleat", "cleat for securing rope"], ["clementine"], ["clip"], ["clipboard"], ["clippers", "clippers for plants"], ["cloak"], ["clock", "timepiece", "timekeeper"], ["clock tower"], ["clothes hamper", "laundry basket", "clothes basket"], ["clothespin", "clothes peg"], ["clutch bag"], ["coaster"], ["coat"], ["coat hanger", "clothes hanger", "dress hanger"], ["coatrack", "hatrack"], ["cock", "rooster"], ["cockroach"], ["cocoa", "cocoa beverage", "hot chocolate", "hot chocolate beverage", "drinking chocolate"], ["coconut", "cocoanut"], ["coffee maker", "coffee machine"], ["coffee table", "cocktail table"], ["coffeepot"], ["coil"], ["coin"], ["colander", "cullender"], ["coleslaw", "slaw"], ["coloring material", "colouring material"], ["combination lock"], ["pacifier", "teething ring"], ["comic book"], ["compass"], ["computer keyboard", "keyboard", "keyboard computer"], ["condiment"], ["cone", "traffic cone"], ["control", "controller"], ["convertible", "convertible automobile"], ["sofa bed"], ["cooker"], ["cookie", "cooky", "biscuit", "biscuit cookie"], ["cooking utensil"], ["cooler", "cooler for food", "ice chest"], ["cork", "cork bottle plug", "bottle cork"], ["corkboard"], ["corkscrew", "bottle screw"], ["edible corn", "corn", "maize"], ["cornbread"], ["cornet", "horn", "trumpet"], ["cornice", "valance", "valance board", "pelmet"], ["cornmeal"], ["corset", "girdle"], ["costume"], ["cougar", "puma", "catamount", "mountain lion", "panther"], ["coverall"], ["cowbell"], ["cowboy hat", "ten-gallon hat"], ["crab", "crab animal"], ["crabmeat"], ["cracker"], ["crape", "crepe", "French pancake"], ["crate"], ["crayon", "wax crayon"], ["cream pitcher"], ["crescent roll", "croissant"], ["crib", "cot"], ["crock pot", "earthenware jar"], ["crossbar"], ["crouton"], ["crow"], ["crowbar", "wrecking bar", "pry bar"], ["crown"], ["crucifix"], ["cruise ship", "cruise liner"], ["police cruiser", "patrol car", "police car", "squad car"], ["crumb"], ["crutch"], ["cub", "cub animal"], ["cube", "square block"], ["cucumber", "cuke"], ["cufflink"], ["cup"], ["trophy cup"], ["cupboard", "closet"], ["cupcake"], ["hair curler", "hair roller", "hair crimper"], ["curling iron"], ["curtain", "drapery"], ["cushion"], ["cylinder"], ["cymbal"], ["dagger"], ["dalmatian"], ["dartboard"], ["date", "date fruit"], ["deck chair", "beach chair"], ["deer", "cervid"], ["dental floss", "floss"], ["desk"], ["detergent"], ["diaper"], ["diary", "journal"], ["die", "dice"], ["dinghy", "dory", "rowboat"], ["dining table"], ["tux", "tuxedo"], ["dish"], ["dish antenna"], ["dishrag", "dishcloth"], ["dishtowel", "tea towel"], ["dishwasher", "dishwashing machine"], ["dishwasher detergent", "dishwashing detergent", "dishwashing liquid", "dishsoap"], ["dispenser"], ["diving board"], ["Dixie cup", "paper cup"], ["dog"], ["dog collar"], ["doll"], ["dollar", "dollar bill", "one dollar bill"], ["dollhouse", "doll's house"], ["dolphin"], ["domestic ass", "donkey"], ["doorknob", "doorhandle"], ["doormat", "welcome mat"], ["doughnut", "donut"], ["dove"], ["dragonfly"], ["drawer"], ["underdrawers", "boxers", "boxershorts"], ["dress", "frock"], ["dress hat", "high hat", "opera hat", "silk hat", "top hat"], ["dress suit"], ["dresser"], ["drill"], ["drone"], ["dropper", "eye dropper"], ["drum", "drum musical instrument"], ["drumstick"], ["duck"], ["duckling"], ["duct tape"], ["duffel bag", "duffle bag", "duffel", "duffle"], ["dumbbell"], ["dumpster"], ["dustpan"], ["eagle"], ["earphone", "earpiece", "headphone"], ["earplug"], ["earring"], ["easel"], ["eclair"], ["eel"], ["egg", "eggs"], ["egg roll", "spring roll"], ["egg yolk", "yolk", "yolk egg"], ["eggbeater", "eggwhisk"], ["eggplant", "aubergine"], ["electric chair"], ["refrigerator"], ["elephant"], ["elk", "moose"], ["envelope"], ["eraser"], ["escargot"], ["eyepatch"], ["falcon"], ["fan"], ["faucet", "spigot", "tap"], ["fedora"], ["ferret"], ["Ferris wheel"], ["ferry", "ferryboat"], ["fig", "fig fruit"], ["fighter jet", "fighter aircraft", "attack aircraft"], ["figurine"], ["file cabinet", "filing cabinet"], ["file", "file tool"], ["fire alarm", "smoke alarm"], ["fire engine", "fire truck"], ["fire extinguisher", "extinguisher"], ["fire hose"], ["fireplace"], ["fireplug", "fire hydrant", "hydrant"], ["first-aid kit"], ["fish"], ["fish", "fish food"], ["fishbowl", "goldfish bowl"], ["fishing rod", "fishing pole"], ["flag"], ["flagpole", "flagstaff"], ["flamingo"], ["flannel"], ["flap"], ["flash", "flashbulb"], ["flashlight", "torch"], ["fleece"], ["flip-flop", "flip-flop sandal"], ["flipper", "flipper footwear", "fin", "fin footwear"], ["flower arrangement", "floral arrangement"], ["flute glass", "champagne flute"], ["foal"], ["folding chair"], ["food processor"], ["football", "football American"], ["football helmet"], ["footstool", "footrest"], ["fork"], ["forklift"], ["freight car"], ["French toast"], ["freshener", "air freshener"], ["frisbee"], ["frog", "toad", "toad frog"], ["fruit juice"], ["frying pan", "frypan", "skillet"], ["fudge"], ["funnel"], ["futon"], ["gag", "muzzle"], ["garbage"], ["garbage truck"], ["garden hose"], ["gargle", "mouthwash"], ["gargoyle"], ["garlic", "ail"], ["gasmask", "respirator", "gas helmet"], ["gazelle"], ["gelatin", "jelly"], ["gemstone"], ["generator"], ["giant panda", "panda", "panda bear"], ["gift wrap"], ["ginger", "gingerroot"], ["giraffe"], ["cincture", "sash", "waistband", "waistcloth"], ["glass", "glass drink container", "drinking glass"], ["globe"], ["glove"], ["goat"], ["goggles"], ["goldfish"], ["golf club", "golf-club"], ["golfcart"], ["gondola", "gondola boat"], ["goose"], ["gorilla"], ["gourd"], ["grape"], ["grater"], ["gravestone", "headstone", "tombstone"], ["gravy boat", "gravy holder"], ["green bean"], ["green onion", "spring onion", "scallion"], ["griddle"], ["grill", "grille", "grillwork", "radiator grille"], ["grits", "hominy grits"], ["grizzly", "grizzly bear"], ["grocery bag"], ["guitar"], ["gull", "seagull"], ["gun"], ["hairbrush"], ["hairnet"], ["hairpin"], ["halter top"], ["ham", "jambon", "gammon"], ["hamburger", "beefburger", "burger"], ["hammer"], ["hammock"], ["hamper"], ["hamster"], ["hair dryer"], ["hand glass", "hand mirror"], ["hand towel", "face towel"], ["handcart", "pushcart", "hand truck"], ["handcuff"], ["handkerchief"], ["handle", "grip", "handgrip"], ["handsaw", "carpenter's saw"], ["hardback book", "hardcover book"], ["harmonium", "organ", "organ musical instrument", "reed organ", "reed organ musical instrument"], ["hat"], ["hatbox"], ["veil"], ["headband"], ["headboard"], ["headlight", "headlamp"], ["headscarf"], ["headset"], ["headstall", "headstall for horses", "headpiece", "headpiece for horses"], ["heart"], ["heater", "warmer"], ["helicopter"], ["helmet"], ["heron"], ["highchair", "feeding chair"], ["hinge"], ["hippopotamus"], ["hockey stick"], ["hog", "pig"], ["home plate", "home plate baseball", "home base", "home base baseball"], ["honey"], ["fume hood", "exhaust hood"], ["hook"], ["hookah", "narghile", "nargileh", "sheesha", "shisha", "water pipe"], ["hornet"], ["horse"], ["hose", "hosepipe"], ["hot-air balloon"], ["hotplate"], ["hot sauce"], ["hourglass"], ["houseboat"], ["hummingbird"], ["hummus", "humus", "hommos", "hoummos", "humous"], ["polar bear"], ["icecream"], ["popsicle"], ["ice maker"], ["ice pack", "ice bag"], ["ice skate"], ["igniter", "ignitor", "lighter"], ["inhaler", "inhalator"], ["iPod"], ["iron", "iron for clothing", "smoothing iron", "smoothing iron for clothing"], ["ironing board"], ["jacket"], ["jam"], ["jar"], ["jean", "blue jean", "denim"], ["jeep", "landrover"], ["jelly bean", "jelly egg"], ["jersey", "T-shirt", "tee shirt"], ["jet plane", "jet-propelled plane"], ["jewel", "gem", "precious stone"], ["jewelry", "jewellery"], ["joystick"], ["jumpsuit"], ["kayak"], ["keg"], ["kennel", "doghouse"], ["kettle", "boiler"], ["key"], ["keycard"], ["kilt"], ["kimono"], ["kitchen sink"], ["kitchen table"], ["kite"], ["kitten", "kitty"], ["kiwi fruit"], ["knee pad"], ["knife"], ["knitting needle"], ["knob"], ["knocker", "knocker on a door", "doorknocker"], ["koala", "koala bear"], ["lab coat", "laboratory coat"], ["ladder"], ["ladle"], ["ladybug", "ladybeetle", "ladybird beetle"], ["lamb", "lamb animal"], ["lamb-chop", "lambchop"], ["lamp"], ["lamppost"], ["lampshade"], ["lantern"], ["lanyard", "laniard"], ["laptop computer", "notebook computer"], ["lasagna", "lasagne"], ["latch"], ["lawn mower"], ["leather"], ["legging", "legging clothing", "leging", "leging clothing", "leg covering"], ["Lego", "Lego set"], ["legume"], ["lemon"], ["lemonade"], ["lettuce"], ["license plate", "numberplate"], ["life buoy", "lifesaver", "life belt", "life ring"], ["life jacket", "life vest"], ["lightbulb"], ["lightning rod", "lightning conductor"], ["lime"], ["limousine"], ["lion"], ["lip balm"], ["liquor", "spirits", "hard liquor", "liqueur", "cordial"], ["lizard"], ["log"], ["lollipop"], ["speaker", "speaker stereo equipment"], ["loveseat"], ["machine gun"], ["magazine"], ["magnet"], ["mail slot"], ["mailbox", "mailbox at home", "letter box", "letter box at home"], ["mallard"], ["mallet"], ["mammoth"], ["manatee"], ["mandarin orange"], ["manger", "trough"], ["manhole"], ["map"], ["marker"], ["martini"], ["mascot"], ["mashed potato"], ["masher"], ["mask", "facemask"], ["mast"], ["mat", "mat gym equipment", "gym mat"], ["matchbox"], ["mattress"], ["measuring cup"], ["measuring stick", "ruler", "ruler measuring stick", "measuring rod"], ["meatball"], ["medicine"], ["melon"], ["microphone"], ["microscope"], ["microwave oven"], ["milestone", "milepost"], ["milk"], ["milk can"], ["milkshake"], ["minivan"], ["mint candy"], ["mirror"], ["mitten"], ["mixer", "mixer kitchen tool", "stand mixer"], ["money"], ["monitor", "monitor computer equipment"], ["monkey"], ["motor"], ["motor scooter", "scooter"], ["motor vehicle", "automotive vehicle"], ["motorcycle"], ["mound", "mound baseball", "pitcher's mound"], ["mouse", "mouse computer equipment", "computer mouse"], ["mousepad"], ["muffin"], ["mug"], ["mushroom"], ["music stool", "piano stool"], ["musical instrument", "instrument", "instrument musical"], ["nailfile"], ["napkin", "table napkin", "serviette"], ["neckerchief"], ["necklace"], ["necktie", "tie", "tie necktie"], ["needle"], ["nest"], ["newspaper", "paper", "paper newspaper"], ["newsstand"], ["nightshirt", "nightwear", "sleepwear", "nightclothes"], ["nosebag", "nosebag for animals", "feedbag"], ["noseband", "noseband for animals", "nosepiece", "nosepiece for animals"], ["notebook"], ["notepad"], ["nut"], ["nutcracker"], ["oar"], ["octopus", "octopus food"], ["octopus", "octopus animal"], ["oil lamp", "kerosene lamp", "kerosine lamp"], ["olive oil"], ["omelet", "omelette"], ["onion"], ["orange", "orange fruit"], ["orange juice"], ["ostrich"], ["ottoman", "pouf", "pouffe", "hassock"], ["oven"], ["overalls", "overalls clothing"], ["owl"], ["packet"], ["inkpad", "inking pad", "stamp pad"], ["pad"], ["paddle", "boat paddle"], ["padlock"], ["paintbrush"], ["painting"], ["pajamas", "pyjamas"], ["palette", "pallet"], ["pan", "pan for cooking", "cooking pan"], ["pan", "pan metal container"], ["pancake"], ["pantyhose"], ["papaya"], ["paper plate"], ["paper towel"], ["paperback book", "paper-back book", "softback book", "soft-cover book"], ["paperweight"], ["parachute"], ["parakeet", "parrakeet", "parroket", "paraquet", "paroquet", "parroquet"], ["parasail", "parasail sports"], ["parasol", "sunshade"], ["parchment"], ["parka", "anorak"], ["parking meter"], ["parrot"], ["passenger car", "passenger car part of a train", "coach", "coach part of a train"], ["passenger ship"], ["passport"], ["pastry"], ["patty", "patty food"], ["pea", "pea food"], ["peach"], ["peanut butter"], ["pear"], ["peeler", "peeler tool for fruit and vegetables"], ["wooden leg", "pegleg"], ["pegboard"], ["pelican"], ["pen"], ["pencil"], ["pencil box", "pencil case"], ["pencil sharpener"], ["pendulum"], ["penguin"], ["pennant"], ["penny", "penny coin"], ["pepper", "peppercorn"], ["pepper mill", "pepper grinder"], ["perfume"], ["persimmon"], ["person", "baby", "child", "boy", "girl", "man", "woman", "human"], ["pet"], ["pew", "pew church bench", "church bench"], ["phonebook", "telephone book", "telephone directory"], ["phonograph record", "phonograph recording", "record", "record phonograph recording"], ["piano"], ["pickle"], ["pickup truck"], ["pie"], ["pigeon"], ["piggy bank", "penny bank"], ["pillow"], ["pin", "pin non jewelry"], ["pineapple"], ["pinecone"], ["ping-pong ball"], ["pinwheel"], ["tobacco pipe"], ["pipe", "piping"], ["pistol", "handgun"], ["pita", "pita bread", "pocket bread"], ["pitcher", "pitcher vessel for liquid", "ewer"], ["pitchfork"], ["pizza"], ["place mat"], ["plate"], ["platter"], ["playpen"], ["pliers", "plyers"], ["plow", "plow farm equipment", "plough", "plough farm equipment"], ["plume"], ["pocket watch"], ["pocketknife"], ["poker", "poker fire stirring tool", "stove poker", "fire hook"], ["pole", "post"], ["polo shirt", "sport shirt"], ["poncho"], ["pony"], ["pool table", "billiard table", "snooker table"], ["pop", "pop soda", "soda", "soda pop", "tonic", "soft drink"], ["postbox", "postbox public", "mailbox", "mailbox public"], ["postcard", "postal card", "mailing-card"], ["poster", "placard"], ["pot"], ["flowerpot"], ["potato"], ["potholder"], ["pottery", "clayware"], ["pouch"], ["power shovel", "excavator", "digger"], ["prawn", "shrimp"], ["pretzel"], ["printer", "printing machine"], ["projectile", "projectile weapon", "missile"], ["projector"], ["propeller", "propellor"], ["prune"], ["pudding"], ["puffer", "puffer fish", "pufferfish", "blowfish", "globefish"], ["puffin"], ["pug-dog"], ["pumpkin"], ["puncher"], ["puppet", "marionette"], ["puppy"], ["quesadilla"], ["quiche"], ["quilt", "comforter"], ["rabbit"], ["race car", "racing car"], ["racket", "racquet"], ["radar"], ["radiator"], ["radio receiver", "radio set", "radio", "tuner", "tuner radio"], ["radish", "daikon"], ["raft"], ["rag doll"], ["raincoat", "waterproof jacket"], ["ram", "ram animal"], ["raspberry"], ["rat"], ["razorblade"], ["reamer", "reamer juicer", "juicer", "juice reamer"], ["rearview mirror"], ["receipt"], ["recliner", "reclining chair", "lounger", "lounger chair"], ["record player", "phonograph", "phonograph record player", "turntable"], ["reflector"], ["remote control"], ["rhinoceros"], ["rib", "rib food"], ["rifle"], ["ring"], ["river boat"], ["road map"], ["robe"], ["rocking chair"], ["rodent"], ["roller skate"], ["Rollerblade"], ["rolling pin"], ["root beer"], ["router", "router computer equipment"], ["rubber band", "elastic band"], ["runner", "runner carpet"], ["plastic bag", "paper bag"], ["saddle", "saddle on an animal"], ["saddle blanket", "saddlecloth", "horse blanket"], ["saddlebag"], ["safety pin"], ["sail"], ["salad"], ["salad plate", "salad bowl"], ["salami"], ["salmon", "salmon fish"], ["salmon", "salmon food"], ["salsa"], ["saltshaker"], ["sandal", "sandal type of shoe"], ["sandwich"], ["satchel"], ["saucepan"], ["saucer"], ["sausage"], ["sawhorse", "sawbuck"], ["saxophone"], ["scale", "scale measuring instrument"], ["scarecrow", "strawman"], ["scarf"], ["school bus"], ["scissors"], ["scoreboard"], ["scraper"], ["screwdriver"], ["scrubbing brush"], ["sculpture"], ["seabird", "seafowl"], ["seahorse"], ["seaplane", "hydroplane"], ["seashell"], ["sewing machine"], ["shaker"], ["shampoo"], ["shark"], ["sharpener"], ["Sharpie"], ["shaver", "shaver electric", "electric shaver", "electric razor"], ["shaving cream", "shaving soap"], ["shawl"], ["shears"], ["sheep"], ["shepherd dog", "sheepdog"], ["sherbert", "sherbet"], ["shield"], ["shirt"], ["shoe", "sneaker", "sneaker type of shoe", "tennis shoe"], ["shopping bag"], ["shopping cart"], ["short pants", "shorts", "shorts clothing", "trunks", "trunks clothing"], ["shot glass"], ["shoulder bag"], ["shovel"], ["shower head"], ["shower cap"], ["shower curtain"], ["shredder", "shredder for paper"], ["signboard"], ["silo"], ["sink"], ["skateboard"], ["skewer"], ["ski"], ["ski boot"], ["ski parka", "ski jacket"], ["ski pole"], ["skirt"], ["skullcap"], ["sled", "sledge", "sleigh"], ["sleeping bag"], ["sling", "sling bandage", "triangular bandage"], ["slipper", "slipper footwear", "carpet slipper", "carpet slipper footwear"], ["smoothie"], ["snake", "serpent"], ["snowboard"], ["snowman"], ["snowmobile"], ["soap"], ["soccer ball"], ["sock"], ["sofa", "couch", "lounge"], ["softball"], ["solar array", "solar battery", "solar panel"], ["sombrero"], ["soup"], ["soup bowl"], ["soupspoon"], ["sour cream", "soured cream"], ["soya milk", "soybean milk", "soymilk"], ["space shuttle"], ["sparkler", "sparkler fireworks"], ["spatula"], ["spear", "lance"], ["spectacles", "specs", "eyeglasses", "glasses"], ["spice rack"], ["spider"], ["crawfish", "crayfish"], ["sponge"], ["spoon"], ["sportswear", "athletic wear", "activewear"], ["spotlight"], ["squid", "squid food", "calamari", "calamary"], ["squirrel"], ["stagecoach"], ["stapler", "stapler stapling machine"], ["starfish", "sea star"], ["statue", "statue sculpture"], ["steak", "steak food"], ["steak knife"], ["steering wheel"], ["stepladder"], ["step stool"], ["stereo", "stereo sound system"], ["stew"], ["stirrer"], ["stirrup"], ["stool"], ["stop sign"], ["brake light"], ["stove", "kitchen stove", "range", "range kitchen appliance", "kitchen range", "cooking stove"], ["strainer"], ["strap"], ["straw", "straw for drinking", "drinking straw"], ["strawberry"], ["street sign"], ["streetlight", "street lamp"], ["string cheese"], ["stylus"], ["subwoofer"], ["sugar bowl"], ["sugarcane", "sugarcane plant"], ["suit", "suit clothing"], ["sunflower"], ["sunglasses"], ["sunhat"], ["surfboard"], ["sushi"], ["mop"], ["sweat pants"], ["sweatband"], ["sweater"], ["sweatshirt"], ["sweet potato"], ["swimsuit", "swimwear", "bathing suit", "swimming costume", "bathing costume", "swimming trunks", "bathing trunks"], ["sword"], ["syringe"], ["Tabasco sauce"], ["table-tennis table", "ping-pong table"], ["table"], ["table lamp"], ["tablecloth"], ["tachometer"], ["taco"], ["tag"], ["taillight", "rear light"], ["tambourine"], ["army tank", "armored combat vehicle", "armoured combat vehicle"], ["tank", "tank storage vessel", "storage tank"], ["tank top", "tank top clothing"], ["tape", "tape sticky cloth or paper"], ["tape measure", "measuring tape"], ["tapestry"], ["tarp"], ["tartan", "plaid"], ["tassel"], ["tea bag"], ["teacup"], ["teakettle"], ["teapot"], ["teddy bear"], ["telephone", "phone", "telephone set"], ["telephone booth", "phone booth", "call box", "telephone box", "telephone kiosk"], ["telephone pole", "telegraph pole", "telegraph post"], ["telephoto lens", "zoom lens"], ["television camera", "tv camera"], ["television set", "tv", "tv set"], ["tennis ball"], ["tennis racket"], ["tequila"], ["thermometer"], ["thermos bottle"], ["thermostat"], ["thimble"], ["thread", "yarn"], ["thumbtack", "drawing pin", "pushpin"], ["tiara"], ["tiger"], ["tights", "tights clothing", "leotards"], ["timer", "stopwatch"], ["tinfoil"], ["tinsel"], ["tissue paper"], ["toast", "toast food"], ["toaster"], ["toaster oven"], ["toilet"], ["toilet tissue", "toilet paper", "bathroom tissue"], ["tomato"], ["tongs"], ["toolbox"], ["toothbrush"], ["toothpaste"], ["toothpick"], ["cover"], ["tortilla"], ["tow truck"], ["towel"], ["towel rack", "towel rail", "towel bar"], ["toy"], ["tractor", "tractor farm equipment"], ["traffic light"], ["dirt bike"], ["trailer truck", "tractor trailer", "trucking rig", "articulated lorry", "semi truck"], ["train", "train railroad vehicle", "railroad train"], ["trampoline"], ["tray"], ["trench coat"], ["triangle", "triangle musical instrument"], ["tricycle"], ["tripod"], ["trousers", "pants", "pants clothing"], ["truck"], ["truffle", "truffle chocolate", "chocolate truffle"], ["trunk"], ["vat"], ["turban"], ["turkey", "turkey food"], ["turnip"], ["turtle"], ["turtleneck", "turtleneck clothing", "polo-neck"], ["typewriter"], ["umbrella"], ["underwear", "underclothes", "underclothing", "underpants"], ["unicycle"], ["urinal"], ["urn"], ["vacuum cleaner"], ["vase"], ["vending machine"], ["vent", "blowhole", "air vent"], ["vest", "waistcoat"], ["videotape"], ["vinegar"], ["violin", "fiddle"], ["vodka"], ["volleyball"], ["vulture"], ["waffle"], ["waffle iron"], ["wagon"], ["wagon wheel"], ["walking stick"], ["wall clock"], ["wall socket", "wall plug", "electric outlet", "electrical outlet", "outlet", "electric receptacle"], ["wallet", "billfold"], ["walrus"], ["wardrobe"], ["washbasin", "basin", "basin for washing", "washbowl", "washstand", "handbasin"], ["automatic washer", "washing machine"], ["watch", "wristwatch"], ["water bottle"], ["water cooler"], ["water faucet", "water tap", "tap", "tap water faucet"], ["water heater", "hot-water heater"], ["water jug"], ["water gun", "squirt gun"], ["water scooter", "sea scooter", "jet ski"], ["water ski"], ["water tower"], ["watering can"], ["watermelon"], ["weathervane", "vane", "vane weathervane", "wind vane"], ["webcam"], ["wedding cake", "bridecake"], ["wedding ring", "wedding band"], ["wet suit"], ["wheel"], ["wheelchair"], ["whipped cream"], ["whistle"], ["wig"], ["wind chime"], ["windmill"], ["window box", "window box for plants"], ["windshield wiper", "windscreen wiper", "wiper", "wiper for windshield or screen"], ["windsock", "air sock", "air-sleeve", "wind sleeve", "wind cone"], ["wine bottle"], ["wine bucket", "wine cooler"], ["wineglass"], ["blinder", "blinder for horses"], ["wok"], ["wolf"], ["wooden spoon"], ["wreath"], ["wrench", "spanner"], ["wristband"], ["wristlet", "wrist band"], ["yacht"], ["yogurt", "yoghurt", "yoghourt"], ["yoke", "yoke animal equipment"], ["zebra"], ["zucchini", "courgette"]] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/obj365v1_class_texts.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/obj365v1_class_texts.json new file mode 100644 index 0000000000000000000000000000000000000000..bddc11c0b9721bb4b7addc9a557a2eed1c9fe0fc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/data/texts/obj365v1_class_texts.json @@ -0,0 +1 @@ +[["person"], ["sneakers"], ["chair"], ["hat"], ["lamp"], ["bottle"], ["cabinet", "shelf"], ["cup"], ["car"], ["glasses"], ["picture", "frame"], ["desk"], ["handbag"], ["street lights"], ["book"], ["plate"], ["helmet"], ["leather shoes"], ["pillow"], ["glove"], ["potted plant"], ["bracelet"], ["flower"], ["tv"], ["storage box"], ["vase"], ["bench"], ["wine glass"], ["boots"], ["bowl"], ["dining table"], ["umbrella"], ["boat"], ["flag"], ["speaker"], ["trash bin", "can"], ["stool"], ["backpack"], ["couch"], ["belt"], ["carpet"], ["basket"], ["towel", "napkin"], ["slippers"], ["barrel", "bucket"], ["coffee table"], ["suv"], ["toy"], ["tie"], ["bed"], ["traffic light"], ["pen", "pencil"], ["microphone"], ["sandals"], ["canned"], ["necklace"], ["mirror"], ["faucet"], ["bicycle"], ["bread"], ["high heels"], ["ring"], ["van"], ["watch"], ["sink"], ["horse"], ["fish"], ["apple"], ["camera"], ["candle"], ["teddy bear"], ["cake"], ["motorcycle"], ["wild bird"], ["laptop"], ["knife"], ["traffic sign"], ["cell phone"], ["paddle"], ["truck"], ["cow"], ["power outlet"], ["clock"], ["drum"], ["fork"], ["bus"], ["hanger"], ["nightstand"], ["pot", "pan"], ["sheep"], ["guitar"], ["traffic cone"], ["tea pot"], ["keyboard"], ["tripod"], ["hockey"], ["fan"], ["dog"], ["spoon"], ["blackboard", "whiteboard"], ["balloon"], ["air conditioner"], ["cymbal"], ["mouse"], ["telephone"], ["pickup truck"], ["orange"], ["banana"], ["airplane"], ["luggage"], ["skis"], ["soccer"], ["trolley"], ["oven"], ["remote"], ["baseball glove"], ["paper towel"], ["refrigerator"], ["train"], ["tomato"], ["machinery vehicle"], ["tent"], ["shampoo", "shower gel"], ["head phone"], ["lantern"], ["donut"], ["cleaning products"], ["sailboat"], ["tangerine"], ["pizza"], ["kite"], ["computer box"], ["elephant"], ["toiletries"], ["gas stove"], ["broccoli"], ["toilet"], ["stroller"], ["shovel"], ["baseball bat"], ["microwave"], ["skateboard"], ["surfboard"], ["surveillance camera"], ["gun"], ["life saver"], ["cat"], ["lemon"], ["liquid soap"], ["zebra"], ["duck"], ["sports car"], ["giraffe"], ["pumpkin"], ["piano"], ["stop sign"], ["radiator"], ["converter"], ["tissue"], ["carrot"], ["washing machine"], ["vent"], ["cookies"], ["cutting", "chopping board"], ["tennis racket"], ["candy"], ["skating and skiing shoes"], ["scissors"], ["folder"], ["baseball"], ["strawberry"], ["bow tie"], ["pigeon"], ["pepper"], ["coffee machine"], ["bathtub"], ["snowboard"], ["suitcase"], ["grapes"], ["ladder"], ["pear"], ["american football"], ["basketball"], ["potato"], ["paint brush"], ["printer"], ["billiards"], ["fire hydrant"], ["goose"], ["projector"], ["sausage"], ["fire extinguisher"], ["extension cord"], ["facial mask"], ["tennis ball"], ["chopsticks"], ["electronic stove and gas stove"], ["pie"], ["frisbee"], ["kettle"], ["hamburger"], ["golf club"], ["cucumber"], ["clutch"], ["blender"], ["tong"], ["slide"], ["hot dog"], ["toothbrush"], ["facial cleanser"], ["mango"], ["deer"], ["egg"], ["violin"], ["marker"], ["ship"], ["chicken"], ["onion"], ["ice cream"], ["tape"], ["wheelchair"], ["plum"], ["bar soap"], ["scale"], ["watermelon"], ["cabbage"], ["router", "modem"], ["golf ball"], ["pine apple"], ["crane"], ["fire truck"], ["peach"], ["cello"], ["notepaper"], ["tricycle"], ["toaster"], ["helicopter"], ["green beans"], ["brush"], ["carriage"], ["cigar"], ["earphone"], ["penguin"], ["hurdle"], ["swing"], ["radio"], ["cd"], ["parking meter"], ["swan"], ["garlic"], ["french fries"], ["horn"], ["avocado"], ["saxophone"], ["trumpet"], ["sandwich"], ["cue"], ["kiwi fruit"], ["bear"], ["fishing rod"], ["cherry"], ["tablet"], ["green vegetables"], ["nuts"], ["corn"], ["key"], ["screwdriver"], ["globe"], ["broom"], ["pliers"], ["volleyball"], ["hammer"], ["eggplant"], ["trophy"], ["dates"], ["board eraser"], ["rice"], ["tape measure", "ruler"], ["dumbbell"], ["hamimelon"], ["stapler"], ["camel"], ["lettuce"], ["goldfish"], ["meat balls"], ["medal"], ["toothpaste"], ["antelope"], ["shrimp"], ["rickshaw"], ["trombone"], ["pomegranate"], ["coconut"], ["jellyfish"], ["mushroom"], ["calculator"], ["treadmill"], ["butterfly"], ["egg tart"], ["cheese"], ["pig"], ["pomelo"], ["race car"], ["rice cooker"], ["tuba"], ["crosswalk sign"], ["papaya"], ["hair drier"], ["green onion"], ["chips"], ["dolphin"], ["sushi"], ["urinal"], ["donkey"], ["electric drill"], ["spring rolls"], ["tortoise", "turtle"], ["parrot"], ["flute"], ["measuring cup"], ["shark"], ["steak"], ["poker card"], ["binoculars"], ["llama"], ["radish"], ["noodles"], ["yak"], ["mop"], ["crab"], ["microscope"], ["barbell"], ["bread", "bun"], ["baozi"], ["lion"], ["red cabbage"], ["polar bear"], ["lighter"], ["seal"], ["mangosteen"], ["comb"], ["eraser"], ["pitaya"], ["scallop"], ["pencil case"], ["saw"], ["table tennis paddle"], ["okra"], ["starfish"], ["eagle"], ["monkey"], ["durian"], ["game board"], ["rabbit"], ["french horn"], ["ambulance"], ["asparagus"], ["hoverboard"], ["pasta"], ["target"], ["hotair balloon"], ["chainsaw"], ["lobster"], ["iron"], ["flashlight"]] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/detect.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/detect.py new file mode 100644 index 0000000000000000000000000000000000000000..d0d0a8769610d577e3798e11f31f451eedcc2441 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/detect.py @@ -0,0 +1,448 @@ +import os +os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' +import json +import cv2 +import mmcv +import torch +import logging +import argparse +import numpy as np +from tqdm import tqdm +import torch.nn.functional as F +from torchvision import transforms +from PIL import Image +from mmengine.dataset import Compose +from mmdet.apis import init_detector +from mmyolo.registry import VISUALIZERS +from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD +from vbench2.third_party.ViTDetector.logger import create_logger +from vbench2.third_party.ViTDetector.config import get_config +from vbench2.third_party.ViTDetector.models import build_model +from torch.nn.parallel import DataParallel +import math +from torchvision import datasets, transforms +from timm.data.transforms import _pil_interp +from collections import defaultdict +from typing import List, Dict + + +logger = create_logger(output_dir='./', dist_rank=0, name="abnormality_detection") + +class Detector: + def __init__(self, config_file, weight_file, device='cuda'): + self.model_human = init_detector(config_file, weight_file, device='cuda') + self.model_face_hand = init_detector(config_file, weight_file, device='cuda') + + # change data loader + self.model_human.cfg.test_dataloader.dataset.pipeline[0].type = 'mmdet.LoadImageFromNDArray' + self.test_pipeline = Compose(self.model_human.cfg.test_dataloader.dataset.pipeline) + + + def inference_detector(self, model, image, texts, test_pipeline, score_thr=0.3): + data_info = dict(img_id=0, img=image, texts=texts) + data_info = test_pipeline(data_info) + data_batch = dict(inputs=data_info['inputs'].unsqueeze(0), + data_samples=[data_info['data_samples']]) + + with torch.no_grad(): + output = model.test_step(data_batch)[0] + pred_instances = output.pred_instances + pred_instances = pred_instances[pred_instances.scores.float() > + score_thr] + output.pred_instances = pred_instances + return output + + def detect_video(self, video_path): + human_text = "human" + human_texts = [[t.strip()] for t in human_text.split(',')] + [[' ']] + # face,hand detection + face_hand_text = "face,hand" + face_hand_texts = [[t.strip()] for t in face_hand_text.split(',')] + [[' ']] + + # text parameter modification + self.model_human.reparameterize(human_texts) + self.model_face_hand.reparameterize(face_hand_texts) + + video_reader = mmcv.VideoReader(video_path) + total_frames = len(video_reader) + + results = [] # save the final results + + + for frame_idx, frame in tqdm(enumerate(video_reader), total=total_frames, desc="processing video frame", disable=True): + annotated_frame = frame.copy() + + # 1. human detection + result_human = self.inference_detector(self.model_human, frame, human_texts, self.test_pipeline, score_thr=0.1) + pred_instances = result_human.pred_instances + human_bboxes = pred_instances.bboxes.cpu().numpy() + + for person_idx, bbox in enumerate(human_bboxes): + # human box results + result_item = { + "frame_index": frame_idx, + "person_index": person_idx, + "bbox": bbox.tolist(), + "label": "human" + } + results.append(result_item) + + x1, y1, x2, y2 = bbox.astype(int) + cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), (0, 255, 0), 2) + cv2.putText(annotated_frame, "human", (x1, max(y1 - 10, 0)), cv2.FONT_HERSHEY_SIMPLEX, + 0.9, (0, 255, 0), 2) + + # crop human + crop = frame[y1:y2, x1:x2] + if crop.size == 0: + continue + + # 2. human face, hand detection + result_face_hand = self.inference_detector(self.model_face_hand, crop, face_hand_texts, self.test_pipeline, score_thr=0.1) + pred_face_hand = result_face_hand.pred_instances + fh_bboxes = pred_face_hand.bboxes.cpu().numpy() + fh_labels = pred_face_hand.labels.cpu().numpy() + + for fh_bbox, label_idx in zip(fh_bboxes, fh_labels): + adj_bbox = [ + float(fh_bbox[0] + x1), + float(fh_bbox[1] + y1), + float(fh_bbox[2] + x1), + float(fh_bbox[3] + y1) + ] + # 0:face, 1:hand + if label_idx == 0: + label = "face" + color = (255, 0, 0) + elif label_idx == 1: + label = "hand" + color = (0, 0, 255) + else: + label = "unknown" + color = (0, 255, 255) + + result_item = { + "frame_index": frame_idx, + "person_index": person_idx, + "bbox": adj_bbox, + "label": label + } + results.append(result_item) + + return results + + +class Analyzer: + def __init__(self, model_configs, device='cuda', batch_size=128, class_thresholds=None): + self.device = device + self.models = {} + self.transforms = {} + self._initialize_models(model_configs) + self.batch_size = batch_size + self.class_threshold = class_thresholds + + def _initialize_models(self, model_configs): + for category, config in model_configs.items(): + model, model_config = self._build_model(config["cfg_path"], config["weight_path"]) + self.models[category] = DataParallel(model).to(self.device).eval() + self.transforms[category] = self._build_transform(model_config) + + def _build_model(self, cfg_path, weight_path): + args = type('Args', (), { + 'cfg': cfg_path, + 'opts': None, + 'local_rank': 0, + })() + config = get_config(args) + model = build_model(config, is_pretrain=False) + checkpoint = torch.load(weight_path, map_location='cpu') + model.load_state_dict(checkpoint['model']) + return model, config + + def _build_transform(self, config): + t = [] + + if config.TEST.CROP: + size = int((256 / 224) * config.DATA.IMG_SIZE) + t.append( + transforms.Resize(size, interpolation=_pil_interp(config.DATA.INTERPOLATION)), + # to maintain same ratio w.r.t. 224 images + ) + t.append(transforms.CenterCrop(config.DATA.IMG_SIZE)) + else: + t.append( + transforms.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE), + interpolation=_pil_interp(config.DATA.INTERPOLATION)) + ) + + t.append(transforms.ToTensor()) + t.append(transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD)) + return transforms.Compose(t) + + def preprocess(self, image: np.ndarray, category: str) -> torch.Tensor: + img = Image.fromarray(image) + img = self.transforms[category](img) + return img.unsqueeze(0) + + + def analyze(self, video_path: str, detection_results: List[dict]) -> Dict: + self.frame_cache = {} + cap = cv2.VideoCapture(video_path) + frame_results = [] + total_abnormal = 0 + total_people = 0 + + # frame level results + frame_detections = defaultdict(list) + for d in detection_results: + frame_detections[d['frame_index']].append(d) + + for frame_idx in tqdm(range(int(cap.get(cv2.CAP_PROP_FRAME_COUNT))), desc="Processing frames", disable=True): + ret, frame = cap.read() + if not ret: + break + + # for cropping + self.frame_cache[frame_idx] = frame + + frame_result = self.process_frame(frame_idx, frame_detections.get(frame_idx, [])) + frame_results.append(frame_result) + + if frame_result['person_count'] > 0: + total_abnormal += frame_result['abnormal_count'] + total_people += frame_result['person_count'] + + cap.release() + del self.frame_cache + + final_score = total_abnormal / total_people if total_people > 0 else 0.0 + return { + 'video_results': 1 - final_score, + 'frame_results': frame_results + } + + def process_frame(self, frame_idx: int, detections: List[dict]) -> Dict: + person_data = defaultdict(dict) + for d in detections: + person_id = d['person_index'] + category = d['label'] + # person_data[person_id][category] = d['bbox'] + if person_id not in person_data: + person_data[person_id] = {} + if category not in person_data[person_id]: + person_data[person_id][category] = [] + person_data[person_id][category].append(d['bbox']) + + batches = defaultdict(lambda: {'images': [], 'person_ids': [], 'bbox': []}) + + for person_id, categories in person_data.items(): + for category in ['human', 'face', 'hand']: + if category in categories: + bboxes = categories[category] + for bbox in bboxes: + image = self.smart_cut(self.frame_cache[frame_idx], bbox) + if image is not None: + batches[category]['images'].append(image) + batches[category]['person_ids'].append(person_id) + batches[category]['bbox'].append(bbox) + + predictions = defaultdict(dict) + for category in batches: + + results = [] + # infer per batchsize + for i in range(0, len(batches[category]['images']), self.batch_size): + results.extend(self.predict_batch(category, batches[category]['images'][i:i+self.batch_size])) + + for pid, pred, bbox in zip(batches[category]['person_ids'], results, batches[category]['bbox']): + # predictions[pid][category] = pred + # maybe more than one prediction for each person and category + if pid not in predictions: + predictions[pid] = {} + if category not in predictions[pid]: + predictions[pid][category] = [] + predictions[pid][category].append((pred, bbox)) + + # abnormal count + abnormal_count = 0 + person_results = [] + for person_id in person_data: + scores = predictions.get(person_id, {}) + # is_abnormal = any(np.argmax(scores.get(cat, [0.5, 0.5])) == 0 for cat in ['human', 'face', 'hand']) + + is_abnormal = False + for cat, cat_scores in scores.items(): + for score, _ in cat_scores: + if cat in self.class_threshold: + if score[0] > self.class_threshold[cat]: + is_abnormal = True + break + if is_abnormal: + break + + person_results.append({ + 'person_id': person_id, + 'abnormal': is_abnormal, + 'scores': scores + }) + abnormal_count += int(is_abnormal) + + return { + 'frame': frame_idx, + 'person_count': len(person_data), + 'abnormal_count': abnormal_count, + 'persons': person_results + } + + def predict_batch(self, category: str, batch: List[np.ndarray]) -> List[List[float]]: + preprocessed = [self.preprocess(img, category) for img in batch] + with torch.no_grad(): + inputs = torch.cat(preprocessed, dim=0).to(self.device) + outputs = self.models[category](inputs).cpu() + return F.softmax(outputs, dim=1).numpy().tolist() + + + + def smart_cut(self, frame, bbox, resize=None): + x1, y1, x2, y2 = map(float, bbox) + H, W = frame.shape[:2] + + # bbox width, height and center calculation + w, h = x2 - x1, y2 - y1 + if w <= 0 or h <= 0: + raise ValueError("Invalid bbox dimensions") + mid_x, mid_y = (x1 + x2)/2, (y1 + y2)/2 + + # crop outer square + max_len = max(w, h) + # range of center movement + x_min = max(x2 - max_len/2, max_len/2) + x_max = min(x1 + max_len/2, W - max_len/2) + y_min = max(y2 - max_len/2, max_len/2) + y_max = min(y1 + max_len/2, H - max_len/2) + + if x_min <= x_max and y_min <= y_max: + # valid point + adj_x = min(max(mid_x, x_min), x_max) + adj_y = min(max(mid_y, y_min), y_max) + # square points calculation + x1_sq = adj_x - max_len/2 + y1_sq = adj_y - max_len/2 + x2_sq, y2_sq = x1_sq + max_len, y1_sq + max_len + + x1_int = math.floor(x1_sq) + y1_int = math.floor(y1_sq) + x2_int = math.ceil(x2_sq) + y2_int = math.ceil(y2_sq) + + # range validation + if x1_int >= 0 and y1_int >= 0 and x2_int <= W and y2_int <= H: + cropped = frame[y1_int:y2_int, x1_int:x2_int] + if cropped.size > 0: + return cv2.resize(cropped, (resize, resize)) if resize else cropped + + # crop inner inner + min_len = min(w, h) + # range of center movement + x_min = max(min_len/2, 0.0) + x_max = W - min_len/2 + y_min = max(min_len/2, 0.0) + y_max = H - min_len/2 + + adj_x = min(max(mid_x, x_min), x_max) + adj_y = min(max(mid_y, y_min), y_max) + + # square points + x1_sq = adj_x - min_len/2 + y1_sq = adj_y - min_len/2 + x2_sq, y2_sq = x1_sq + min_len, y1_sq + min_len + + x1_int = math.floor(x1_sq) + y1_int = math.floor(y1_sq) + x2_int = math.ceil(x2_sq) + y2_int = math.ceil(y2_sq) + + if x1_int >= 0 and y1_int >= 0 and x2_int <= W and y2_int <= H: + cropped = frame[y1_int:y2_int, x1_int:x2_int] + if cropped.size > 0: + return cv2.resize(cropped, (resize, resize)) if resize else cropped + + raise ValueError("Cannot crop valid region within frame") + + def _process_predictions(self, predictions, threshold): + return [p[0] > threshold for p in predictions] + +def compute_abnormality(video_paths, device, submodules_dict, **kwargs): + # Initialize components + detector = Detector( + config_file=submodules_dict["detector_config"], + weight_file=submodules_dict["detector_weights"], + device=device + ) + + analyzer = Analyzer( + model_configs=submodules_dict["analyzer_configs"], + device=device, + batch_size=submodules_dict["batch_size"], + class_thresholds={k: v["threshold"] for k, v in submodules_dict["analyzer_configs"].items()} + ) + + all_results = [] + for video_path in tqdm(video_paths): + + detections = detector.detect_video(video_path) + + result = analyzer.analyze( + video_path=video_path, + detection_results=detections, + ) + + all_results.append({ + "video_path": video_path, + 'video_results': result['video_results'], + }) + + global_score = sum([x['video_results'] for x in all_results]) / len(all_results) + + return global_score, all_results + +def parse_option(): + parser = argparse.ArgumentParser('training and evaluation script', add_help=False) + # easy config modification + parser.add_argument('--human_model', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--face_model', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--hand_model', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--detector_config', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--detector_weights', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--cfg', type=str, required=True, help='path to pre-trained model') + + args = parser.parse_args() + + return args + +if __name__ == "__main__": + args = parse_option() + submodules = { + "detector_config": args.detector_config, #"yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py", + "detector_weights": args.detector_weights, #"yolo_world_v2_xl_obj365v1_goldg_cc3mlite_pretrain-5daf1395.pth", + "analyzer_configs": { + "human": {"cfg_path": args.cfg, "weight_path": args.human_model, "threshold": 0.4545454545454546}, + "face": {"cfg_path": args.cfg, "weight_path": args.face_model, "threshold": 0.30303030303030304}, + "hand": {"cfg_path": args.cfg, "weight_path": args.hand_model, "threshold": 0.3232} + }, + "batch_size" : 128 + } + + video_paths = [ + "exmaple/people are walking.-1.mp4", + ] + + final_score, detailed_results = compute_abnormality( + video_paths=video_paths, + device="cuda", + submodules_dict=submodules + ) + with open("test_results.json", "w") as f: + json.dump(detailed_results, f) + + print(f"Global Abnormality Score: {final_score:.4f}") \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/exmaple/people are walking.-1.mp4 b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/exmaple/people are walking.-1.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..bf6327c180434fccab3a5f719255eb70631c59a8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/exmaple/people are walking.-1.mp4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:084c18d612ca78a781df6bac3470cf06453d15477642e854c8f8fd4cf46e881f +size 2496108 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/hack_registry.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/hack_registry.py new file mode 100644 index 0000000000000000000000000000000000000000..f710cfbd3988a4621087ac74ea533c68147387a1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/hack_registry.py @@ -0,0 +1,45 @@ +# hack_registry.py +import logging + +from mmengine.registry import Registry +from mmengine.logging import print_log +from typing import Type, Optional, Union, List + + +def _register_module(self, + module: Type, + module_name: Optional[Union[str, List[str]]] = None, + force: bool = False) -> None: + """Register a module. + + Args: + module (type): Module to be registered. Typically a class or a + function, but generally all ``Callable`` are acceptable. + module_name (str or list of str, optional): The module name to be + registered. If not specified, the class name will be used. + Defaults to None. + force (bool): Whether to override an existing class with the same + name. Defaults to False. + """ + if not callable(module): + raise TypeError(f'module must be Callable, but got {type(module)}') + + if module_name is None: + module_name = module.__name__ + if isinstance(module_name, str): + module_name = [module_name] + for name in module_name: + if not force and name in self._module_dict: + existed_module = self.module_dict[name] + # raise KeyError(f'{name} is already registered in {self.name} ' + # f'at {existed_module.__module__}') + print_log( + f'{name} is already registered in {self.name} ' + f'at {existed_module.__module__}. Registration ignored.', + logger='current', + level=logging.INFO + ) + self._module_dict[name] = module + + +Registry._register_module = _register_module \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/inference.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/inference.py new file mode 100644 index 0000000000000000000000000000000000000000..8c85e17d176f2d9da6c04efef7f00c27bdf5db6c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/inference.py @@ -0,0 +1,449 @@ +import os +os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' +import json +import cv2 +import mmcv +import torch +import logging +import argparse +import hack_registry +import numpy as np +from tqdm import tqdm +import torch.nn.functional as F +from torchvision import transforms +from PIL import Image +from mmengine.dataset import Compose +from mmdet.apis import init_detector +from mmyolo.registry import VISUALIZERS +from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD +from logger import create_logger +from config import get_config +from models import build_model +from torch.nn.parallel import DataParallel +import math +from torchvision import datasets, transforms +from timm.data.transforms import _pil_interp +from collections import defaultdict +from typing import List, Dict + + +logger = create_logger(output_dir='./', dist_rank=0, name="abnormality_detection") + +class Detector: + def __init__(self, config_file, weight_file, device='cuda'): + self.model_human = init_detector(config_file, weight_file, device='cuda') + self.model_face_hand = init_detector(config_file, weight_file, device='cuda') + + # change data loader + self.model_human.cfg.test_dataloader.dataset.pipeline[0].type = 'mmdet.LoadImageFromNDArray' + self.test_pipeline = Compose(self.model_human.cfg.test_dataloader.dataset.pipeline) + + + def inference_detector(self, model, image, texts, test_pipeline, score_thr=0.3): + data_info = dict(img_id=0, img=image, texts=texts) + data_info = test_pipeline(data_info) + data_batch = dict(inputs=data_info['inputs'].unsqueeze(0), + data_samples=[data_info['data_samples']]) + + with torch.no_grad(): + output = model.test_step(data_batch)[0] + pred_instances = output.pred_instances + pred_instances = pred_instances[pred_instances.scores.float() > + score_thr] + output.pred_instances = pred_instances + return output + + def detect_video(self, video_path): + human_text = "human" + human_texts = [[t.strip()] for t in human_text.split(',')] + [[' ']] + # face,hand detection + face_hand_text = "face,hand" + face_hand_texts = [[t.strip()] for t in face_hand_text.split(',')] + [[' ']] + + # text parameter modification + self.model_human.reparameterize(human_texts) + self.model_face_hand.reparameterize(face_hand_texts) + + video_reader = mmcv.VideoReader(video_path) + total_frames = len(video_reader) + + results = [] # save the final results + + + for frame_idx, frame in tqdm(enumerate(video_reader), total=total_frames, desc="processing video frame", disable=True): + annotated_frame = frame.copy() + + # 1. human detection + result_human = self.inference_detector(self.model_human, frame, human_texts, self.test_pipeline, score_thr=0.1) + pred_instances = result_human.pred_instances + human_bboxes = pred_instances.bboxes.cpu().numpy() + + for person_idx, bbox in enumerate(human_bboxes): + # human box results + result_item = { + "frame_index": frame_idx, + "person_index": person_idx, + "bbox": bbox.tolist(), + "label": "human" + } + results.append(result_item) + + x1, y1, x2, y2 = bbox.astype(int) + cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), (0, 255, 0), 2) + cv2.putText(annotated_frame, "human", (x1, max(y1 - 10, 0)), cv2.FONT_HERSHEY_SIMPLEX, + 0.9, (0, 255, 0), 2) + + # crop human + crop = frame[y1:y2, x1:x2] + if crop.size == 0: + continue + + # 2. human face, hand detection + result_face_hand = self.inference_detector(self.model_face_hand, crop, face_hand_texts, self.test_pipeline, score_thr=0.1) + pred_face_hand = result_face_hand.pred_instances + fh_bboxes = pred_face_hand.bboxes.cpu().numpy() + fh_labels = pred_face_hand.labels.cpu().numpy() + + for fh_bbox, label_idx in zip(fh_bboxes, fh_labels): + adj_bbox = [ + float(fh_bbox[0] + x1), + float(fh_bbox[1] + y1), + float(fh_bbox[2] + x1), + float(fh_bbox[3] + y1) + ] + # 0:face, 1:hand + if label_idx == 0: + label = "face" + color = (255, 0, 0) + elif label_idx == 1: + label = "hand" + color = (0, 0, 255) + else: + label = "unknown" + color = (0, 255, 255) + + result_item = { + "frame_index": frame_idx, + "person_index": person_idx, + "bbox": adj_bbox, + "label": label + } + results.append(result_item) + + return results + + +class Analyzer: + def __init__(self, model_configs, device='cuda', batch_size=128, class_thresholds=None): + self.device = device + self.models = {} + self.transforms = {} + self._initialize_models(model_configs) + self.batch_size = batch_size + self.class_threshold = class_thresholds + + def _initialize_models(self, model_configs): + for category, config in model_configs.items(): + model, model_config = self._build_model(config["cfg_path"], config["weight_path"]) + self.models[category] = DataParallel(model).to(self.device).eval() + self.transforms[category] = self._build_transform(model_config) + + def _build_model(self, cfg_path, weight_path): + args = type('Args', (), { + 'cfg': cfg_path, + 'opts': None, + 'local_rank': 0, + })() + config = get_config(args) + model = build_model(config, is_pretrain=False) + checkpoint = torch.load(weight_path, map_location='cpu') + model.load_state_dict(checkpoint['model']) + return model, config + + def _build_transform(self, config): + t = [] + + if config.TEST.CROP: + size = int((256 / 224) * config.DATA.IMG_SIZE) + t.append( + transforms.Resize(size, interpolation=_pil_interp(config.DATA.INTERPOLATION)), + # to maintain same ratio w.r.t. 224 images + ) + t.append(transforms.CenterCrop(config.DATA.IMG_SIZE)) + else: + t.append( + transforms.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE), + interpolation=_pil_interp(config.DATA.INTERPOLATION)) + ) + + t.append(transforms.ToTensor()) + t.append(transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD)) + return transforms.Compose(t) + + def preprocess(self, image: np.ndarray, category: str) -> torch.Tensor: + img = Image.fromarray(image) + img = self.transforms[category](img) + return img.unsqueeze(0) + + + def analyze(self, video_path: str, detection_results: List[dict]) -> Dict: + self.frame_cache = {} + cap = cv2.VideoCapture(video_path) + frame_results = [] + total_abnormal = 0 + total_people = 0 + + # frame level results + frame_detections = defaultdict(list) + for d in detection_results: + frame_detections[d['frame_index']].append(d) + + for frame_idx in tqdm(range(int(cap.get(cv2.CAP_PROP_FRAME_COUNT))), desc="Processing frames", disable=True): + ret, frame = cap.read() + if not ret: + break + + # for cropping + self.frame_cache[frame_idx] = frame + + frame_result = self.process_frame(frame_idx, frame_detections.get(frame_idx, [])) + frame_results.append(frame_result) + + if frame_result['person_count'] > 0: + total_abnormal += frame_result['abnormal_count'] + total_people += frame_result['person_count'] + + cap.release() + del self.frame_cache + + final_score = total_abnormal / total_people if total_people > 0 else 0.0 + return { + 'video_results': 1 - final_score, + 'frame_results': frame_results + } + + def process_frame(self, frame_idx: int, detections: List[dict]) -> Dict: + person_data = defaultdict(dict) + for d in detections: + person_id = d['person_index'] + category = d['label'] + # person_data[person_id][category] = d['bbox'] + if person_id not in person_data: + person_data[person_id] = {} + if category not in person_data[person_id]: + person_data[person_id][category] = [] + person_data[person_id][category].append(d['bbox']) + + batches = defaultdict(lambda: {'images': [], 'person_ids': [], 'bbox': []}) + + for person_id, categories in person_data.items(): + for category in ['human', 'face', 'hand']: + if category in categories: + bboxes = categories[category] + for bbox in bboxes: + image = self.smart_cut(self.frame_cache[frame_idx], bbox) + if image is not None: + batches[category]['images'].append(image) + batches[category]['person_ids'].append(person_id) + batches[category]['bbox'].append(bbox) + + predictions = defaultdict(dict) + for category in batches: + + results = [] + # infer per batchsize + for i in range(0, len(batches[category]['images']), self.batch_size): + results.extend(self.predict_batch(category, batches[category]['images'][i:i+self.batch_size])) + + for pid, pred, bbox in zip(batches[category]['person_ids'], results, batches[category]['bbox']): + # predictions[pid][category] = pred + # maybe more than one prediction for each person and category + if pid not in predictions: + predictions[pid] = {} + if category not in predictions[pid]: + predictions[pid][category] = [] + predictions[pid][category].append((pred, bbox)) + + # abnormal count + abnormal_count = 0 + person_results = [] + for person_id in person_data: + scores = predictions.get(person_id, {}) + # is_abnormal = any(np.argmax(scores.get(cat, [0.5, 0.5])) == 0 for cat in ['human', 'face', 'hand']) + + is_abnormal = False + for cat, cat_scores in scores.items(): + for score, _ in cat_scores: + if cat in self.class_threshold: + if score[0] > self.class_threshold[cat]: + is_abnormal = True + break + if is_abnormal: + break + + person_results.append({ + 'person_id': person_id, + 'abnormal': is_abnormal, + 'scores': scores + }) + abnormal_count += int(is_abnormal) + + return { + 'frame': frame_idx, + 'person_count': len(person_data), + 'abnormal_count': abnormal_count, + 'persons': person_results + } + + def predict_batch(self, category: str, batch: List[np.ndarray]) -> List[List[float]]: + preprocessed = [self.preprocess(img, category) for img in batch] + with torch.no_grad(): + inputs = torch.cat(preprocessed, dim=0).to(self.device) + outputs = self.models[category](inputs).cpu() + return F.softmax(outputs, dim=1).numpy().tolist() + + + + def smart_cut(self, frame, bbox, resize=None): + x1, y1, x2, y2 = map(float, bbox) + H, W = frame.shape[:2] + + # bbox width, height and center calculation + w, h = x2 - x1, y2 - y1 + if w <= 0 or h <= 0: + raise ValueError("Invalid bbox dimensions") + mid_x, mid_y = (x1 + x2)/2, (y1 + y2)/2 + + # crop outer square + max_len = max(w, h) + # range of center movement + x_min = max(x2 - max_len/2, max_len/2) + x_max = min(x1 + max_len/2, W - max_len/2) + y_min = max(y2 - max_len/2, max_len/2) + y_max = min(y1 + max_len/2, H - max_len/2) + + if x_min <= x_max and y_min <= y_max: + # valid point + adj_x = min(max(mid_x, x_min), x_max) + adj_y = min(max(mid_y, y_min), y_max) + # square points calculation + x1_sq = adj_x - max_len/2 + y1_sq = adj_y - max_len/2 + x2_sq, y2_sq = x1_sq + max_len, y1_sq + max_len + + x1_int = math.floor(x1_sq) + y1_int = math.floor(y1_sq) + x2_int = math.ceil(x2_sq) + y2_int = math.ceil(y2_sq) + + # range validation + if x1_int >= 0 and y1_int >= 0 and x2_int <= W and y2_int <= H: + cropped = frame[y1_int:y2_int, x1_int:x2_int] + if cropped.size > 0: + return cv2.resize(cropped, (resize, resize)) if resize else cropped + + # crop inner inner + min_len = min(w, h) + # range of center movement + x_min = max(min_len/2, 0.0) + x_max = W - min_len/2 + y_min = max(min_len/2, 0.0) + y_max = H - min_len/2 + + adj_x = min(max(mid_x, x_min), x_max) + adj_y = min(max(mid_y, y_min), y_max) + + # square points + x1_sq = adj_x - min_len/2 + y1_sq = adj_y - min_len/2 + x2_sq, y2_sq = x1_sq + min_len, y1_sq + min_len + + x1_int = math.floor(x1_sq) + y1_int = math.floor(y1_sq) + x2_int = math.ceil(x2_sq) + y2_int = math.ceil(y2_sq) + + if x1_int >= 0 and y1_int >= 0 and x2_int <= W and y2_int <= H: + cropped = frame[y1_int:y2_int, x1_int:x2_int] + if cropped.size > 0: + return cv2.resize(cropped, (resize, resize)) if resize else cropped + + raise ValueError("Cannot crop valid region within frame") + + def _process_predictions(self, predictions, threshold): + return [p[0] > threshold for p in predictions] + +def compute_abnormality(video_paths, device, submodules_dict, **kwargs): + # Initialize components + detector = Detector( + config_file=submodules_dict["detector_config"], + weight_file=submodules_dict["detector_weights"], + device=device + ) + + analyzer = Analyzer( + model_configs=submodules_dict["analyzer_configs"], + device=device, + batch_size=submodules_dict["batch_size"], + class_thresholds={k: v["threshold"] for k, v in submodules_dict["analyzer_configs"].items()} + ) + + all_results = [] + for video_path in tqdm(video_paths): + + detections = detector.detect_video(video_path) + + result = analyzer.analyze( + video_path=video_path, + detection_results=detections, + ) + + all_results.append({ + "video_path": video_path, + 'video_results': result['video_results'], + }) + + global_score = sum([x['video_results'] for x in all_results]) / len(all_results) + + return global_score, all_results + +def parse_option(): + parser = argparse.ArgumentParser('training and evaluation script', add_help=False) + # easy config modification + parser.add_argument('--human_model', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--face_model', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--hand_model', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--detector_config', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--detector_weights', type=str, required=True, help='path to pre-trained model') + parser.add_argument('--cfg', type=str, required=True, help='path to pre-trained model') + + args = parser.parse_args() + + return args + +if __name__ == "__main__": + args = parse_option() + submodules = { + "detector_config": args.detector_config, #"yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py", + "detector_weights": args.detector_weights, #"yolo_world_v2_xl_obj365v1_goldg_cc3mlite_pretrain-5daf1395.pth", + "analyzer_configs": { + "human": {"cfg_path": args.cfg, "weight_path": args.human_model, "threshold": 0.4545454545454546}, + "face": {"cfg_path": args.cfg, "weight_path": args.face_model, "threshold": 0.30303030303030304}, + "hand": {"cfg_path": args.cfg, "weight_path": args.hand_model, "threshold": 0.3232} + }, + "batch_size" : 128 + } + + video_paths = [ + "exmaple/people are walking.-1.mp4", + ] + + final_score, detailed_results = compute_abnormality( + video_paths=video_paths, + device="cuda", + submodules_dict=submodules + ) + with open("test_results.json", "w") as f: + json.dump(detailed_results, f) + + print(f"Global Abnormality Score: {final_score:.4f}") \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/logger.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/logger.py new file mode 100644 index 0000000000000000000000000000000000000000..f7d95b21648bd00a57ff7d0107064d425308a580 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/logger.py @@ -0,0 +1,42 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +import os +import sys +import logging +import functools +from termcolor import colored + + +@functools.lru_cache() +def create_logger(output_dir, dist_rank=0, name=''): + # create logger + logger = logging.getLogger(name) + logger.setLevel(logging.DEBUG) + logger.propagate = False + + # create formatter + fmt = '[%(asctime)s %(name)s] (%(filename)s %(lineno)d): %(levelname)s %(message)s' + color_fmt = colored('[%(asctime)s %(name)s]', 'green') + \ + colored('(%(filename)s %(lineno)d)', 'yellow') + ': %(levelname)s %(message)s' + + # create console handlers for master process + if dist_rank == 0: + console_handler = logging.StreamHandler(sys.stdout) + console_handler.setLevel(logging.DEBUG) + console_handler.setFormatter( + logging.Formatter(fmt=color_fmt, datefmt='%Y-%m-%d %H:%M:%S')) + logger.addHandler(console_handler) + + # create file handlers + file_handler = logging.FileHandler(os.path.join(output_dir, f'log_rank{dist_rank}.txt'), mode='a') + file_handler.setLevel(logging.DEBUG) + file_handler.setFormatter(logging.Formatter(fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')) + logger.addHandler(file_handler) + + return logger diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lr_scheduler.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..ee27b8cd5867c849e1f2d9eead752c49990fcb55 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lr_scheduler.py @@ -0,0 +1,153 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +from collections import Counter +from bisect import bisect_right + +import torch +from timm.scheduler.cosine_lr import CosineLRScheduler +from timm.scheduler.step_lr import StepLRScheduler +from timm.scheduler.scheduler import Scheduler + + +def build_scheduler(config, optimizer, n_iter_per_epoch): + num_steps = int(config.TRAIN.EPOCHS * n_iter_per_epoch) + warmup_steps = int(config.TRAIN.WARMUP_EPOCHS * n_iter_per_epoch) + decay_steps = int(config.TRAIN.LR_SCHEDULER.DECAY_EPOCHS * n_iter_per_epoch) + multi_steps = [i * n_iter_per_epoch for i in config.TRAIN.LR_SCHEDULER.MULTISTEPS] + + lr_scheduler = None + if config.TRAIN.LR_SCHEDULER.NAME == 'cosine': + lr_scheduler = CosineLRScheduler( + optimizer, + t_initial=num_steps, + t_mul=1., + lr_min=config.TRAIN.MIN_LR, + warmup_lr_init=config.TRAIN.WARMUP_LR, + warmup_t=warmup_steps, + cycle_limit=1, + t_in_epochs=False, + ) + elif config.TRAIN.LR_SCHEDULER.NAME == 'linear': + lr_scheduler = LinearLRScheduler( + optimizer, + t_initial=num_steps, + lr_min_rate=0.01, + warmup_lr_init=config.TRAIN.WARMUP_LR, + warmup_t=warmup_steps, + t_in_epochs=False, + ) + elif config.TRAIN.LR_SCHEDULER.NAME == 'step': + lr_scheduler = StepLRScheduler( + optimizer, + decay_t=decay_steps, + decay_rate=config.TRAIN.LR_SCHEDULER.DECAY_RATE, + warmup_lr_init=config.TRAIN.WARMUP_LR, + warmup_t=warmup_steps, + t_in_epochs=False, + ) + elif config.TRAIN.LR_SCHEDULER.NAME == 'multistep': + lr_scheduler = MultiStepLRScheduler( + optimizer, + milestones=multi_steps, + gamma=config.TRAIN.LR_SCHEDULER.GAMMA, + warmup_lr_init=config.TRAIN.WARMUP_LR, + warmup_t=warmup_steps, + t_in_epochs=False, + ) + + return lr_scheduler + + +class LinearLRScheduler(Scheduler): + def __init__(self, + optimizer: torch.optim.Optimizer, + t_initial: int, + lr_min_rate: float, + warmup_t=0, + warmup_lr_init=0., + t_in_epochs=True, + noise_range_t=None, + noise_pct=0.67, + noise_std=1.0, + noise_seed=42, + initialize=True, + ) -> None: + super().__init__( + optimizer, param_group_field="lr", + noise_range_t=noise_range_t, noise_pct=noise_pct, noise_std=noise_std, noise_seed=noise_seed, + initialize=initialize) + + self.t_initial = t_initial + self.lr_min_rate = lr_min_rate + self.warmup_t = warmup_t + self.warmup_lr_init = warmup_lr_init + self.t_in_epochs = t_in_epochs + if self.warmup_t: + self.warmup_steps = [(v - warmup_lr_init) / self.warmup_t for v in self.base_values] + super().update_groups(self.warmup_lr_init) + else: + self.warmup_steps = [1 for _ in self.base_values] + + def _get_lr(self, t): + if t < self.warmup_t: + lrs = [self.warmup_lr_init + t * s for s in self.warmup_steps] + else: + t = t - self.warmup_t + total_t = self.t_initial - self.warmup_t + lrs = [v - ((v - v * self.lr_min_rate) * (t / total_t)) for v in self.base_values] + return lrs + + def get_epoch_values(self, epoch: int): + if self.t_in_epochs: + return self._get_lr(epoch) + else: + return None + + def get_update_values(self, num_updates: int): + if not self.t_in_epochs: + return self._get_lr(num_updates) + else: + return None + + +class MultiStepLRScheduler(Scheduler): + def __init__(self, optimizer: torch.optim.Optimizer, milestones, gamma=0.1, warmup_t=0, warmup_lr_init=0, t_in_epochs=True) -> None: + super().__init__(optimizer, param_group_field="lr") + + self.milestones = milestones + self.gamma = gamma + self.warmup_t = warmup_t + self.warmup_lr_init = warmup_lr_init + self.t_in_epochs = t_in_epochs + if self.warmup_t: + self.warmup_steps = [(v - warmup_lr_init) / self.warmup_t for v in self.base_values] + super().update_groups(self.warmup_lr_init) + else: + self.warmup_steps = [1 for _ in self.base_values] + + assert self.warmup_t <= min(self.milestones) + + def _get_lr(self, t): + if t < self.warmup_t: + lrs = [self.warmup_lr_init + t * s for s in self.warmup_steps] + else: + lrs = [v * (self.gamma ** bisect_right(self.milestones, t)) for v in self.base_values] + return lrs + + def get_epoch_values(self, epoch: int): + if self.t_in_epochs: + return self._get_lr(epoch) + else: + return None + + def get_update_values(self, num_updates: int): + if not self.t_in_epochs: + return self._get_lr(num_updates) + else: + return None \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lvis/lvis_v1_minival_inserted_image_name.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lvis/lvis_v1_minival_inserted_image_name.json new file mode 100644 index 0000000000000000000000000000000000000000..6bd2c04ec085318789058f787969998cafe4976d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/lvis/lvis_v1_minival_inserted_image_name.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02301f6ccd89d1ee3d35112cb57d000c3396f34e4073066c90b2c1fbf47b55ce +size 35463626 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/main_finetune.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/main_finetune.py new file mode 100644 index 0000000000000000000000000000000000000000..210822a946c1c742e57ad0465b6e30fab9e2670a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/main_finetune.py @@ -0,0 +1,380 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +import os +import time +import argparse +import datetime +import numpy as np + +import torch +import torch.backends.cudnn as cudnn +import torch.distributed as dist + +from timm.loss import LabelSmoothingCrossEntropy, SoftTargetCrossEntropy +from timm.utils import accuracy, AverageMeter + +from config import get_config +from models import build_model +from data import build_loader +from lr_scheduler import build_scheduler +from optimizer import build_optimizer +from logger import create_logger +from utils import load_checkpoint, load_pretrained, save_checkpoint, get_grad_norm, auto_resume_helper, reduce_tensor +import torch.amp as amp +import torch.nn as nn +import torch.nn.functional as F + +class FocalLoss(nn.Module): + def __init__(self, alpha=0.25, gamma=2.0, reduction='mean'): + super().__init__() + self.alpha = torch.tensor([alpha, 1 - alpha]).cuda() + self.gamma = gamma + self.reduction = reduction + + def forward(self, inputs, targets): + BCE_loss = F.cross_entropy(inputs, targets, reduction='none') + pt = torch.exp(-BCE_loss) + alpha_t = self.alpha[targets.long()] + + F_loss = alpha_t * (1 - pt) ** self.gamma * BCE_loss + + if self.reduction == 'mean': + return torch.mean(F_loss) + elif self.reduction == 'sum': + return torch.sum(F_loss) + return F_loss + + +def parse_option(): + parser = argparse.ArgumentParser('training and evaluation script', add_help=False) + parser.add_argument('--cfg', type=str, required=True, metavar="FILE", help='path to config file', ) + + + parser.add_argument('--focal-loss', action='store_true', help='use focal loss') + parser.add_argument('--focal-alpha', type=float, default=0.25, help='alpha for focal loss') + parser.add_argument('--focal-gamma', type=float, default=2.0, help='gamma for focal loss') + parser.add_argument( + "--opts", + help="Modify config options by adding 'KEY VALUE' pairs. ", + default=None, + nargs='+', + ) + + # easy config modification + parser.add_argument('--batch-size', type=int, help="batch size for single GPU") + parser.add_argument('--train-path', type=str, help="path to training dataset") + parser.add_argument('--val-path', type=str, help="path to validation dataset") + parser.add_argument('--pretrained', type=str, help='path to pre-trained model') + parser.add_argument('--resume', help='resume from checkpoint') + parser.add_argument('--accumulation-steps', type=int, help="gradient accumulation steps") + parser.add_argument('--use-checkpoint', action='store_true', + help="whether to use gradient checkpointing to save memory") + parser.add_argument('--amp-opt-level', type=str, default='O0', choices=['O0', 'O1', 'O2'], + help='mixed precision opt level, if O0, no amp is used') + parser.add_argument('--output', default='output', type=str, metavar='PATH', + help='root of output folder, the full path is // (default: output)') + parser.add_argument('--tag', help='tag of experiment') + parser.add_argument('--eval', action='store_true', help='Perform evaluation only') + parser.add_argument('--throughput', action='store_true', help='Test throughput only') + + # distributed training + parser.add_argument("--local-rank", type=int, default=0) + + args = parser.parse_args() + + config = get_config(args) + + + return args, config + + +def main(config): + + + dataset_train, dataset_val, data_loader_train, data_loader_val, mixup_fn = build_loader(config, logger, is_pretrain=False) + + logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") + model = build_model(config, is_pretrain=False) + model.cuda() + logger.info(str(model)) + + optimizer = build_optimizer(config, model, logger, is_pretrain=False) + if config.AMP_OPT_LEVEL != "O0": + model, optimizer = amp.initialize(model, optimizer, opt_level=config.AMP_OPT_LEVEL) + + local_rank = os.environ['LOCAL_RANK'] + model = torch.nn.parallel.DistributedDataParallel(model, device_ids=['cuda'], broadcast_buffers=False) + model_without_ddp = model.module + + n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad) + logger.info(f"number of params: {n_parameters}") + if hasattr(model_without_ddp, 'flops'): + flops = model_without_ddp.flops() + logger.info(f"number of GFLOPs: {flops / 1e9}") + + lr_scheduler = build_scheduler(config, optimizer, len(data_loader_train)) + + if config.AUG.MIXUP > 0.: + # smoothing is handled with mixup label transform + criterion = SoftTargetCrossEntropy() + elif config.MODEL.LABEL_SMOOTHING > 0.: + criterion = LabelSmoothingCrossEntropy(smoothing=config.MODEL.LABEL_SMOOTHING) + elif config.LOSS.FOCAL: + logger.info(f"Using Focal Loss with alpha={config.LOSS.FOCAL_ALPHA}, gamma={config.LOSS.FOCAL_GAMMA}") + criterion = FocalLoss(alpha=config.LOSS.FOCAL_ALPHA, gamma=config.LOSS.FOCAL_GAMMA) + else: + criterion = torch.nn.CrossEntropyLoss() + + max_accuracy = 0.0 + + if config.TRAIN.AUTO_RESUME: + resume_file = auto_resume_helper(config.OUTPUT, logger) + if resume_file: + if config.MODEL.RESUME: + logger.warning(f"auto-resume changing resume file from {config.MODEL.RESUME} to {resume_file}") + config.defrost() + config.MODEL.RESUME = resume_file + config.freeze() + logger.info(f'auto resuming from {resume_file}') + else: + logger.info(f'no checkpoint found in {config.OUTPUT}, ignoring auto resume') + + if config.MODEL.RESUME: + max_accuracy = load_checkpoint(config, model_without_ddp, optimizer, lr_scheduler, logger) + acc1, loss = validate(config, data_loader_val, model) + logger.info(f"Accuracy of the network on the {len(dataset_val)} test images: {acc1:.1f}%") + if config.EVAL_MODE: + return + elif config.PRETRAINED: + load_pretrained(config, model_without_ddp, logger) + + if config.THROUGHPUT_MODE: + throughput(data_loader_val, model, logger) + return + + logger.info("Start training") + start_time = time.time() + for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): + data_loader_train.sampler.set_epoch(epoch) + + train_one_epoch(config, model, criterion, data_loader_train, optimizer, epoch, mixup_fn, lr_scheduler) + if dist.get_rank() == 0 and (epoch % config.SAVE_FREQ == 0 or epoch == (config.TRAIN.EPOCHS - 1)): + save_checkpoint(config, epoch, model_without_ddp, max_accuracy, optimizer, lr_scheduler, logger) + + acc1, loss = validate(config, data_loader_val, model) + logger.info(f"Accuracy of the network on the {len(dataset_val)} test images: {acc1:.1f}%") + max_accuracy = max(max_accuracy, acc1) + logger.info(f'Max accuracy: {max_accuracy:.2f}%') + + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + logger.info('Training time {}'.format(total_time_str)) + + +def train_one_epoch(config, model, criterion, data_loader, optimizer, epoch, mixup_fn, lr_scheduler): + model.train() + optimizer.zero_grad() + + logger.info(f'Current learning rate for different parameter groups: {[it["lr"] for it in optimizer.param_groups]}') + + num_steps = len(data_loader) + batch_time = AverageMeter() + loss_meter = AverageMeter() + norm_meter = AverageMeter() + + start = time.time() + end = time.time() + for idx, (samples, targets) in enumerate(data_loader): + samples = samples.cuda(non_blocking=True) + targets = targets.cuda(non_blocking=True) + + if mixup_fn is not None: + samples, targets = mixup_fn(samples, targets) + + outputs = model(samples) + + if config.TRAIN.ACCUMULATION_STEPS > 1: + loss = criterion(outputs, targets) + loss = loss / config.TRAIN.ACCUMULATION_STEPS + if config.AMP_OPT_LEVEL != "O0": + with amp.scale_loss(loss, optimizer) as scaled_loss: + scaled_loss.backward() + if config.TRAIN.CLIP_GRAD: + grad_norm = torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), config.TRAIN.CLIP_GRAD) + else: + grad_norm = get_grad_norm(amp.master_params(optimizer)) + else: + loss.backward() + if config.TRAIN.CLIP_GRAD: + grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), config.TRAIN.CLIP_GRAD) + else: + grad_norm = get_grad_norm(model.parameters()) + if (idx + 1) % config.TRAIN.ACCUMULATION_STEPS == 0: + optimizer.step() + optimizer.zero_grad() + lr_scheduler.step_update(epoch * num_steps + idx) + else: + loss = criterion(outputs, targets) + optimizer.zero_grad() + if config.AMP_OPT_LEVEL != "O0": + with amp.scale_loss(loss, optimizer) as scaled_loss: + scaled_loss.backward() + if config.TRAIN.CLIP_GRAD: + grad_norm = torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), config.TRAIN.CLIP_GRAD) + else: + grad_norm = get_grad_norm(amp.master_params(optimizer)) + else: + loss.backward() + if config.TRAIN.CLIP_GRAD: + grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), config.TRAIN.CLIP_GRAD) + else: + grad_norm = get_grad_norm(model.parameters()) + optimizer.step() + lr_scheduler.step_update(epoch * num_steps + idx) + + torch.cuda.synchronize() + + loss_meter.update(loss.item(), targets.size(0)) + norm_meter.update(grad_norm) + batch_time.update(time.time() - end) + end = time.time() + + if idx % config.PRINT_FREQ == 0: + lr = optimizer.param_groups[-1]['lr'] + memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) + etas = batch_time.avg * (num_steps - idx) + logger.info( + f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' + f'eta {datetime.timedelta(seconds=int(etas))} lr {lr:.6f}\t' + f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' + f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' + f'grad_norm {norm_meter.val:.4f} ({norm_meter.avg:.4f})\t' + f'mem {memory_used:.0f}MB') + epoch_time = time.time() - start + logger.info(f"EPOCH {epoch} training takes {datetime.timedelta(seconds=int(epoch_time))}") + + + +@torch.no_grad() +def validate(config, data_loader, model): + criterion = torch.nn.CrossEntropyLoss() + model.eval() + + batch_time = AverageMeter() + loss_meter = AverageMeter() + acc1_meter = AverageMeter() + + end = time.time() + for idx, (images, target) in enumerate(data_loader): + images = images.cuda(non_blocking=True) + target = target.cuda(non_blocking=True) + + # compute output + output = model(images) + + # measure accuracy and record loss + loss = criterion(output, target) + acc1 = accuracy(output, target, topk=(1,))[0] # 只计算top1准确率 + + acc1 = reduce_tensor(acc1) + loss = reduce_tensor(loss) + + loss_meter.update(loss.item(), target.size(0)) + acc1_meter.update(acc1.item(), target.size(0)) + + # measure elapsed time + batch_time.update(time.time() - end) + end = time.time() + + if idx % config.PRINT_FREQ == 0: + memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) + logger.info( + f'Test: [{idx}/{len(data_loader)}]\t' + f'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' + f'Loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' + f'Acc@1 {acc1_meter.val:.3f} ({acc1_meter.avg:.3f})\t' + f'Mem {memory_used:.0f}MB') + + logger.info(f' * Acc@1 {acc1_meter.avg:.3f}') + return acc1_meter.avg, loss_meter.avg + + + +@torch.no_grad() +def throughput(data_loader, model, logger): + model.eval() + + for idx, (images, _) in enumerate(data_loader): + images = images.cuda(non_blocking=True) + batch_size = images.shape[0] + for i in range(50): + model(images) + torch.cuda.synchronize() + logger.info(f"throughput averaged with 30 times") + tic1 = time.time() + for i in range(30): + model(images) + torch.cuda.synchronize() + tic2 = time.time() + logger.info(f"batch_size {batch_size} throughput {30 * batch_size / (tic2 - tic1)}") + return + + +if __name__ == '__main__': + print(torch.cuda.is_available()) + _, config = parse_option() + + if config.AMP_OPT_LEVEL != "O0": + assert amp is not None, "amp not installed!" + + if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: + rank = int(os.environ["RANK"]) + world_size = int(os.environ['WORLD_SIZE']) + print(f"RANK and WORLD_SIZE in environ: {rank}/{world_size}") + else: + rank = -1 + world_size = -1 + #torch.cuda.set_device(config.LOCAL_RANK) + torch.distributed.init_process_group(backend='nccl', init_method='env://', world_size=world_size, rank=rank) + torch.distributed.barrier() + + seed = config.SEED + dist.get_rank() + torch.manual_seed(seed) + np.random.seed(seed) + cudnn.benchmark = True + + # linear scale the learning rate according to total batch size, may not be optimal + linear_scaled_lr = config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size() / 128.0 + linear_scaled_warmup_lr = config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size() / 128.0 + linear_scaled_min_lr = config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size() / 128.0 + # gradient accumulation also need to scale the learning rate + if config.TRAIN.ACCUMULATION_STEPS > 1: + linear_scaled_lr = linear_scaled_lr * config.TRAIN.ACCUMULATION_STEPS + linear_scaled_warmup_lr = linear_scaled_warmup_lr * config.TRAIN.ACCUMULATION_STEPS + linear_scaled_min_lr = linear_scaled_min_lr * config.TRAIN.ACCUMULATION_STEPS + config.defrost() + config.TRAIN.BASE_LR = linear_scaled_lr + config.TRAIN.WARMUP_LR = linear_scaled_warmup_lr + config.TRAIN.MIN_LR = linear_scaled_min_lr + config.OUTPUT = os.path.join(config.OUTPUT.split('/')[0], config.OUTPUT.split('/')[1]) + config.freeze() + + os.makedirs(config.OUTPUT, exist_ok=True) + logger = create_logger(output_dir=config.OUTPUT, dist_rank=dist.get_rank(), name=f"{config.MODEL.NAME}") + + if dist.get_rank() == 0: + path = os.path.join(config.OUTPUT, "config.json") + with open(path, "w") as f: + f.write(config.dump()) + logger.info(f"Full config saved to {path}") + + # print config + logger.info(config.dump()) + + main(config) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2d9c65e39f0fb592bd09ebd5eaba754c5a8f192e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/__init__.py @@ -0,0 +1 @@ +from .build import build_model \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/build.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/build.py new file mode 100644 index 0000000000000000000000000000000000000000..ff9cc594227522a08f9287abab5bef6730554627 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/build.py @@ -0,0 +1,26 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +from .swin_transformer import build_swin +from .vision_transformer import build_vit +from .simmim import build_simmim + + +def build_model(config, is_pretrain=True): + if is_pretrain: + model = build_simmim(config) + else: + model_type = config.MODEL.TYPE + if model_type == 'swin': + model = build_swin(config) + elif model_type == 'vit': + model = build_vit(config) + else: + raise NotImplementedError(f"Unknown fine-tune model: {model_type}") + + return model diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/simmim.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/simmim.py new file mode 100644 index 0000000000000000000000000000000000000000..297f35fc18a1ebd8a765bc22652c27c1c7442497 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/simmim.py @@ -0,0 +1,182 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Zhenda Xie +# -------------------------------------------------------- + +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F +from timm.models.layers import trunc_normal_ + +from .swin_transformer import SwinTransformer +from .vision_transformer import VisionTransformer + + +class SwinTransformerForSimMIM(SwinTransformer): + def __init__(self, **kwargs): + super().__init__(**kwargs) + + assert self.num_classes == 0 + + self.mask_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim)) + trunc_normal_(self.mask_token, mean=0., std=.02) + + def forward(self, x, mask): + x = self.patch_embed(x) + + assert mask is not None + B, L, _ = x.shape + + mask_tokens = self.mask_token.expand(B, L, -1) + w = mask.flatten(1).unsqueeze(-1).type_as(mask_tokens) + x = x * (1. - w) + mask_tokens * w + + if self.ape: + x = x + self.absolute_pos_embed + x = self.pos_drop(x) + + for layer in self.layers: + x = layer(x) + x = self.norm(x) + + x = x.transpose(1, 2) + B, C, L = x.shape + H = W = int(L ** 0.5) + x = x.reshape(B, C, H, W) + return x + + @torch.jit.ignore + def no_weight_decay(self): + return super().no_weight_decay() | {'mask_token'} + + +class VisionTransformerForSimMIM(VisionTransformer): + def __init__(self, **kwargs): + super().__init__(**kwargs) + + assert self.num_classes == 0 + + self.mask_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim)) + self._trunc_normal_(self.mask_token, std=.02) + + def _trunc_normal_(self, tensor, mean=0., std=1.): + trunc_normal_(tensor, mean=mean, std=std, a=-std, b=std) + + def forward(self, x, mask): + x = self.patch_embed(x) + + assert mask is not None + B, L, _ = x.shape + + mask_token = self.mask_token.expand(B, L, -1) + w = mask.flatten(1).unsqueeze(-1).type_as(mask_token) + x = x * (1 - w) + mask_token * w + + cls_tokens = self.cls_token.expand(B, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + + if self.pos_embed is not None: + x = x + self.pos_embed + x = self.pos_drop(x) + + rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None + for blk in self.blocks: + x = blk(x, rel_pos_bias=rel_pos_bias) + x = self.norm(x) + + x = x[:, 1:] + B, L, C = x.shape + H = W = int(L ** 0.5) + x = x.permute(0, 2, 1).reshape(B, C, H, W) + return x + + +class SimMIM(nn.Module): + def __init__(self, encoder, encoder_stride): + super().__init__() + self.encoder = encoder + self.encoder_stride = encoder_stride + + self.decoder = nn.Sequential( + nn.Conv2d( + in_channels=self.encoder.num_features, + out_channels=self.encoder_stride ** 2 * 3, kernel_size=1), + nn.PixelShuffle(self.encoder_stride), + ) + + self.in_chans = self.encoder.in_chans + self.patch_size = self.encoder.patch_size + + def forward(self, x, mask): + z = self.encoder(x, mask) + x_rec = self.decoder(z) + + mask = mask.repeat_interleave(self.patch_size, 1).repeat_interleave(self.patch_size, 2).unsqueeze(1).contiguous() + loss_recon = F.l1_loss(x, x_rec, reduction='none') + loss = (loss_recon * mask).sum() / (mask.sum() + 1e-5) / self.in_chans + return loss + + @torch.jit.ignore + def no_weight_decay(self): + if hasattr(self.encoder, 'no_weight_decay'): + return {'encoder.' + i for i in self.encoder.no_weight_decay()} + return {} + + @torch.jit.ignore + def no_weight_decay_keywords(self): + if hasattr(self.encoder, 'no_weight_decay_keywords'): + return {'encoder.' + i for i in self.encoder.no_weight_decay_keywords()} + return {} + + +def build_simmim(config): + model_type = config.MODEL.TYPE + if model_type == 'swin': + encoder = SwinTransformerForSimMIM( + img_size=config.DATA.IMG_SIZE, + patch_size=config.MODEL.SWIN.PATCH_SIZE, + in_chans=config.MODEL.SWIN.IN_CHANS, + num_classes=0, + embed_dim=config.MODEL.SWIN.EMBED_DIM, + depths=config.MODEL.SWIN.DEPTHS, + num_heads=config.MODEL.SWIN.NUM_HEADS, + window_size=config.MODEL.SWIN.WINDOW_SIZE, + mlp_ratio=config.MODEL.SWIN.MLP_RATIO, + qkv_bias=config.MODEL.SWIN.QKV_BIAS, + qk_scale=config.MODEL.SWIN.QK_SCALE, + drop_rate=config.MODEL.DROP_RATE, + drop_path_rate=config.MODEL.DROP_PATH_RATE, + ape=config.MODEL.SWIN.APE, + patch_norm=config.MODEL.SWIN.PATCH_NORM, + use_checkpoint=config.TRAIN.USE_CHECKPOINT) + encoder_stride = 32 + elif model_type == 'vit': + encoder = VisionTransformerForSimMIM( + img_size=config.DATA.IMG_SIZE, + patch_size=config.MODEL.VIT.PATCH_SIZE, + in_chans=config.MODEL.VIT.IN_CHANS, + num_classes=0, + embed_dim=config.MODEL.VIT.EMBED_DIM, + depth=config.MODEL.VIT.DEPTH, + num_heads=config.MODEL.VIT.NUM_HEADS, + mlp_ratio=config.MODEL.VIT.MLP_RATIO, + qkv_bias=config.MODEL.VIT.QKV_BIAS, + drop_rate=config.MODEL.DROP_RATE, + drop_path_rate=config.MODEL.DROP_PATH_RATE, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + init_values=config.MODEL.VIT.INIT_VALUES, + use_abs_pos_emb=config.MODEL.VIT.USE_APE, + use_rel_pos_bias=config.MODEL.VIT.USE_RPB, + use_shared_rel_pos_bias=config.MODEL.VIT.USE_SHARED_RPB, + use_mean_pooling=config.MODEL.VIT.USE_MEAN_POOLING) + encoder_stride = 16 + else: + raise NotImplementedError(f"Unknown pre-train model: {model_type}") + + model = SimMIM(encoder=encoder, encoder_stride=encoder_stride) + + return model diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/swin_transformer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/swin_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..56783400cad7bb32ec5b0f116f8f187bb9f91b67 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/swin_transformer.py @@ -0,0 +1,612 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +import torch +import torch.nn as nn +import torch.utils.checkpoint as checkpoint +from timm.models.layers import DropPath, to_2tuple, trunc_normal_ + + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +def window_partition(x, window_size): + """ + Args: + x: (B, H, W, C) + window_size (int): window size + + Returns: + windows: (num_windows*B, window_size, window_size, C) + """ + B, H, W, C = x.shape + x = x.view(B, H // window_size, window_size, W // window_size, window_size, C) + windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C) + return windows + + +def window_reverse(windows, window_size, H, W): + """ + Args: + windows: (num_windows*B, window_size, window_size, C) + window_size (int): Window size + H (int): Height of image + W (int): Width of image + + Returns: + x: (B, H, W, C) + """ + B = int(windows.shape[0] / (H * W / window_size / window_size)) + x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1) + x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1) + return x + + +class WindowAttention(nn.Module): + r""" Window based multi-head self attention (W-MSA) module with relative position bias. + It supports both of shifted and non-shifted window. + + Args: + dim (int): Number of input channels. + window_size (tuple[int]): The height and width of the window. + num_heads (int): Number of attention heads. + qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set + attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0 + proj_drop (float, optional): Dropout ratio of output. Default: 0.0 + """ + + def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.): + + super().__init__() + self.dim = dim + self.window_size = window_size # Wh, Ww + self.num_heads = num_heads + head_dim = dim // num_heads + self.scale = qk_scale or head_dim ** -0.5 + + # define a parameter table of relative position bias + self.relative_position_bias_table = nn.Parameter( + torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 2*Wh-1 * 2*Ww-1, nH + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(self.window_size[0]) + coords_w = torch.arange(self.window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += self.window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1 + relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + self.register_buffer("relative_position_index", relative_position_index) + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + trunc_normal_(self.relative_position_bias_table, std=.02) + self.softmax = nn.Softmax(dim=-1) + + def forward(self, x, mask=None): + """ + Args: + x: input features with shape of (num_windows*B, N, C) + mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None + """ + B_, N, C = x.shape + qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) + q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = (q @ k.transpose(-2, -1)) + + relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view( + self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # Wh*Ww,Wh*Ww,nH + relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + attn = attn + relative_position_bias.unsqueeze(0) + + if mask is not None: + nW = mask.shape[0] + attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0) + attn = attn.view(-1, self.num_heads, N, N) + attn = self.softmax(attn) + else: + attn = self.softmax(attn) + + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B_, N, C) + x = self.proj(x) + x = self.proj_drop(x) + return x + + def extra_repr(self) -> str: + return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}' + + def flops(self, N): + # calculate flops for 1 window with token length of N + flops = 0 + # qkv = self.qkv(x) + flops += N * self.dim * 3 * self.dim + # attn = (q @ k.transpose(-2, -1)) + flops += self.num_heads * N * (self.dim // self.num_heads) * N + # x = (attn @ v) + flops += self.num_heads * N * N * (self.dim // self.num_heads) + # x = self.proj(x) + flops += N * self.dim * self.dim + return flops + + +class SwinTransformerBlock(nn.Module): + r""" Swin Transformer Block. + + Args: + dim (int): Number of input channels. + input_resolution (tuple[int]): Input resulotion. + num_heads (int): Number of attention heads. + window_size (int): Window size. + shift_size (int): Shift size for SW-MSA. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. + qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set. + drop (float, optional): Dropout rate. Default: 0.0 + attn_drop (float, optional): Attention dropout rate. Default: 0.0 + drop_path (float, optional): Stochastic depth rate. Default: 0.0 + act_layer (nn.Module, optional): Activation layer. Default: nn.GELU + norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm + """ + + def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0, + mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0., + act_layer=nn.GELU, norm_layer=nn.LayerNorm): + super().__init__() + self.dim = dim + self.input_resolution = input_resolution + self.num_heads = num_heads + self.window_size = window_size + self.shift_size = shift_size + self.mlp_ratio = mlp_ratio + if min(self.input_resolution) <= self.window_size: + # if window size is larger than input resolution, we don't partition windows + self.shift_size = 0 + self.window_size = min(self.input_resolution) + assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size" + + self.norm1 = norm_layer(dim) + self.attn = WindowAttention( + dim, window_size=to_2tuple(self.window_size), num_heads=num_heads, + qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop) + + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + if self.shift_size > 0: + # calculate attention mask for SW-MSA + H, W = self.input_resolution + img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1 + h_slices = (slice(0, -self.window_size), + slice(-self.window_size, -self.shift_size), + slice(-self.shift_size, None)) + w_slices = (slice(0, -self.window_size), + slice(-self.window_size, -self.shift_size), + slice(-self.shift_size, None)) + cnt = 0 + for h in h_slices: + for w in w_slices: + img_mask[:, h, w, :] = cnt + cnt += 1 + + mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1 + mask_windows = mask_windows.view(-1, self.window_size * self.window_size) + attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2) + attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0)) + else: + attn_mask = None + + self.register_buffer("attn_mask", attn_mask) + + def forward(self, x): + H, W = self.input_resolution + B, L, C = x.shape + assert L == H * W, "input feature has wrong size" + + shortcut = x + x = self.norm1(x) + x = x.view(B, H, W, C) + + # cyclic shift + if self.shift_size > 0: + shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2)) + else: + shifted_x = x + + # partition windows + x_windows = window_partition(shifted_x, self.window_size) # nW*B, window_size, window_size, C + x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C + + # W-MSA/SW-MSA + attn_windows = self.attn(x_windows, mask=self.attn_mask) # nW*B, window_size*window_size, C + + # merge windows + attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C) + shifted_x = window_reverse(attn_windows, self.window_size, H, W) # B H' W' C + + # reverse cyclic shift + if self.shift_size > 0: + x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2)) + else: + x = shifted_x + x = x.view(B, H * W, C) + + # FFN + x = shortcut + self.drop_path(x) + x = x + self.drop_path(self.mlp(self.norm2(x))) + + return x + + def extra_repr(self) -> str: + return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \ + f"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}" + + def flops(self): + flops = 0 + H, W = self.input_resolution + # norm1 + flops += self.dim * H * W + # W-MSA/SW-MSA + nW = H * W / self.window_size / self.window_size + flops += nW * self.attn.flops(self.window_size * self.window_size) + # mlp + flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio + # norm2 + flops += self.dim * H * W + return flops + + +class PatchMerging(nn.Module): + r""" Patch Merging Layer. + + Args: + input_resolution (tuple[int]): Resolution of input feature. + dim (int): Number of input channels. + norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm + """ + + def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm): + super().__init__() + self.input_resolution = input_resolution + self.dim = dim + self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False) + self.norm = norm_layer(4 * dim) + + def forward(self, x): + """ + x: B, H*W, C + """ + H, W = self.input_resolution + B, L, C = x.shape + assert L == H * W, "input feature has wrong size" + assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even." + + x = x.view(B, H, W, C) + + x0 = x[:, 0::2, 0::2, :] # B H/2 W/2 C + x1 = x[:, 1::2, 0::2, :] # B H/2 W/2 C + x2 = x[:, 0::2, 1::2, :] # B H/2 W/2 C + x3 = x[:, 1::2, 1::2, :] # B H/2 W/2 C + x = torch.cat([x0, x1, x2, x3], -1) # B H/2 W/2 4*C + x = x.view(B, -1, 4 * C) # B H/2*W/2 4*C + + x = self.norm(x) + x = self.reduction(x) + + return x + + def extra_repr(self) -> str: + return f"input_resolution={self.input_resolution}, dim={self.dim}" + + def flops(self): + H, W = self.input_resolution + flops = H * W * self.dim + flops += (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim + return flops + + +class BasicLayer(nn.Module): + """ A basic Swin Transformer layer for one stage. + + Args: + dim (int): Number of input channels. + input_resolution (tuple[int]): Input resolution. + depth (int): Number of blocks. + num_heads (int): Number of attention heads. + window_size (int): Local window size. + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. + qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set. + drop (float, optional): Dropout rate. Default: 0.0 + attn_drop (float, optional): Attention dropout rate. Default: 0.0 + drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0 + norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm + downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None + use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False. + """ + + def __init__(self, dim, input_resolution, depth, num_heads, window_size, + mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False): + + super().__init__() + self.dim = dim + self.input_resolution = input_resolution + self.depth = depth + self.use_checkpoint = use_checkpoint + + # build blocks + self.blocks = nn.ModuleList([ + SwinTransformerBlock(dim=dim, input_resolution=input_resolution, + num_heads=num_heads, window_size=window_size, + shift_size=0 if (i % 2 == 0) else window_size // 2, + mlp_ratio=mlp_ratio, + qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop, attn_drop=attn_drop, + drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path, + norm_layer=norm_layer) + for i in range(depth)]) + + # patch merging layer + if downsample is not None: + self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer) + else: + self.downsample = None + + def forward(self, x): + for blk in self.blocks: + if self.use_checkpoint: + x = checkpoint.checkpoint(blk, x) + else: + x = blk(x) + if self.downsample is not None: + x = self.downsample(x) + return x + + def extra_repr(self) -> str: + return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}" + + def flops(self): + flops = 0 + for blk in self.blocks: + flops += blk.flops() + if self.downsample is not None: + flops += self.downsample.flops() + return flops + + +class PatchEmbed(nn.Module): + r""" Image to Patch Embedding + + Args: + img_size (int): Image size. Default: 224. + patch_size (int): Patch token size. Default: 4. + in_chans (int): Number of input image channels. Default: 3. + embed_dim (int): Number of linear projection output channels. Default: 96. + norm_layer (nn.Module, optional): Normalization layer. Default: None + """ + + def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]] + self.img_size = img_size + self.patch_size = patch_size + self.patches_resolution = patches_resolution + self.num_patches = patches_resolution[0] * patches_resolution[1] + + self.in_chans = in_chans + self.embed_dim = embed_dim + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + if norm_layer is not None: + self.norm = norm_layer(embed_dim) + else: + self.norm = None + + def forward(self, x): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) # B Ph*Pw C + if self.norm is not None: + x = self.norm(x) + return x + + def flops(self): + Ho, Wo = self.patches_resolution + flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1]) + if self.norm is not None: + flops += Ho * Wo * self.embed_dim + return flops + + +class SwinTransformer(nn.Module): + r""" Swin Transformer + A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` - + https://arxiv.org/pdf/2103.14030 + + Args: + img_size (int | tuple(int)): Input image size. Default 224 + patch_size (int | tuple(int)): Patch size. Default: 4 + in_chans (int): Number of input image channels. Default: 3 + num_classes (int): Number of classes for classification head. Default: 1000 + embed_dim (int): Patch embedding dimension. Default: 96 + depths (tuple(int)): Depth of each Swin Transformer layer. + num_heads (tuple(int)): Number of attention heads in different layers. + window_size (int): Window size. Default: 7 + mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4 + qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True + qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None + drop_rate (float): Dropout rate. Default: 0 + attn_drop_rate (float): Attention dropout rate. Default: 0 + drop_path_rate (float): Stochastic depth rate. Default: 0.1 + norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm. + ape (bool): If True, add absolute position embedding to the patch embedding. Default: False + patch_norm (bool): If True, add normalization after patch embedding. Default: True + use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False + """ + + def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000, + embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24], + window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None, + drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1, + norm_layer=nn.LayerNorm, ape=False, patch_norm=True, + use_checkpoint=False, **kwargs): + super().__init__() + + self.img_size = img_size + self.patch_size = patch_size + self.in_chans = in_chans + + self.num_classes = num_classes + self.num_layers = len(depths) + self.embed_dim = embed_dim + self.ape = ape + self.patch_norm = patch_norm + self.num_features = int(embed_dim * 2 ** (self.num_layers - 1)) + self.mlp_ratio = mlp_ratio + + # split image into non-overlapping patches + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, + norm_layer=norm_layer if self.patch_norm else None) + num_patches = self.patch_embed.num_patches + patches_resolution = self.patch_embed.patches_resolution + self.patches_resolution = patches_resolution + + # absolute position embedding + if self.ape: + self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim)) + trunc_normal_(self.absolute_pos_embed, std=.02) + + self.pos_drop = nn.Dropout(p=drop_rate) + + # stochastic depth + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule + + # build layers + self.layers = nn.ModuleList() + for i_layer in range(self.num_layers): + layer = BasicLayer(dim=int(embed_dim * 2 ** i_layer), + input_resolution=(patches_resolution[0] // (2 ** i_layer), + patches_resolution[1] // (2 ** i_layer)), + depth=depths[i_layer], + num_heads=num_heads[i_layer], + window_size=window_size, + mlp_ratio=self.mlp_ratio, + qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, + drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])], + norm_layer=norm_layer, + downsample=PatchMerging if (i_layer < self.num_layers - 1) else None, + use_checkpoint=use_checkpoint) + self.layers.append(layer) + + self.norm = norm_layer(self.num_features) + self.avgpool = nn.AdaptiveAvgPool1d(1) + self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity() + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + + @torch.jit.ignore + def no_weight_decay(self): + return {'absolute_pos_embed'} + + @torch.jit.ignore + def no_weight_decay_keywords(self): + return {'relative_position_bias_table'} + + def forward_features(self, x): + x = self.patch_embed(x) + if self.ape: + x = x + self.absolute_pos_embed + x = self.pos_drop(x) + + for layer in self.layers: + x = layer(x) + + x = self.norm(x) # B L C + x = self.avgpool(x.transpose(1, 2)) # B C 1 + x = torch.flatten(x, 1) + return x + + def forward(self, x): + x = self.forward_features(x) + x = self.head(x) + return x + + def flops(self): + flops = 0 + flops += self.patch_embed.flops() + for i, layer in enumerate(self.layers): + flops += layer.flops() + flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers) + flops += self.num_features * self.num_classes + return flops + + +def build_swin(config): + model = SwinTransformer( + img_size=config.DATA.IMG_SIZE, + patch_size=config.MODEL.SWIN.PATCH_SIZE, + in_chans=config.MODEL.SWIN.IN_CHANS, + num_classes=config.MODEL.NUM_CLASSES, + embed_dim=config.MODEL.SWIN.EMBED_DIM, + depths=config.MODEL.SWIN.DEPTHS, + num_heads=config.MODEL.SWIN.NUM_HEADS, + window_size=config.MODEL.SWIN.WINDOW_SIZE, + mlp_ratio=config.MODEL.SWIN.MLP_RATIO, + qkv_bias=config.MODEL.SWIN.QKV_BIAS, + qk_scale=config.MODEL.SWIN.QK_SCALE, + drop_rate=config.MODEL.DROP_RATE, + drop_path_rate=config.MODEL.DROP_PATH_RATE, + ape=config.MODEL.SWIN.APE, + patch_norm=config.MODEL.SWIN.PATCH_NORM, + use_checkpoint=config.TRAIN.USE_CHECKPOINT) + + return model \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/vision_transformer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/vision_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..0820ddcbac52758cf8cdd1c6fbe7a6810bba5d11 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/models/vision_transformer.py @@ -0,0 +1,355 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Based on BEIT code bases (https://github.com/microsoft/unilm/tree/master/beit) +# Written by Yutong Lin, Zhenda Xie +# -------------------------------------------------------- + +import math +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F +from timm.models.layers import DropPath, to_2tuple, trunc_normal_ + + +class Mlp(nn.Module): + def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): + super().__init__() + out_features = out_features or in_features + hidden_features = hidden_features or in_features + self.fc1 = nn.Linear(in_features, hidden_features) + self.act = act_layer() + self.fc2 = nn.Linear(hidden_features, out_features) + self.drop = nn.Dropout(drop) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + # x = self.drop(x) + # comment out this for the orignal BERT implement + x = self.fc2(x) + x = self.drop(x) + return x + + +class Attention(nn.Module): + def __init__( + self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., + proj_drop=0., window_size=None, attn_head_dim=None): + super().__init__() + self.num_heads = num_heads + head_dim = dim // num_heads + if attn_head_dim is not None: + head_dim = attn_head_dim + all_head_dim = head_dim * self.num_heads + self.scale = qk_scale or head_dim ** -0.5 + + self.qkv = nn.Linear(dim, all_head_dim * 3, bias=False) + if qkv_bias: + self.q_bias = nn.Parameter(torch.zeros(all_head_dim)) + self.v_bias = nn.Parameter(torch.zeros(all_head_dim)) + else: + self.q_bias = None + self.v_bias = None + + if window_size: + self.window_size = window_size + # cls to token & token to cls & cls to cls + self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3 + self.relative_position_bias_table = nn.Parameter( + torch.zeros(self.num_relative_distance, num_heads)) # 2*Wh-1 * 2*Ww-1, nH + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(window_size[0]) + coords_w = torch.arange(window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * window_size[1] - 1 + relative_position_index = \ + torch.zeros(size=(window_size[0] * window_size[1] + 1, ) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = self.num_relative_distance - 3 + relative_position_index[0:, 0] = self.num_relative_distance - 2 + relative_position_index[0, 0] = self.num_relative_distance - 1 + + self.register_buffer("relative_position_index", relative_position_index) + else: + self.window_size = None + self.relative_position_bias_table = None + self.relative_position_index = None + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(all_head_dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x, rel_pos_bias=None): + B, N, C = x.shape + qkv_bias = None + if self.q_bias is not None: + qkv_bias = torch.cat((self.q_bias, torch.zeros_like(self.v_bias, requires_grad=False), self.v_bias)) + qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias) + qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = (q @ k.transpose(-2, -1)) + + if self.relative_position_bias_table is not None: + relative_position_bias = \ + self.relative_position_bias_table[self.relative_position_index.view(-1)].view( + self.window_size[0] * self.window_size[1] + 1, + self.window_size[0] * self.window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + attn = attn + relative_position_bias.unsqueeze(0) + + if rel_pos_bias is not None: + attn = attn + rel_pos_bias + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, -1) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +class Block(nn.Module): + + def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0., + drop_path=0., init_values=None, act_layer=nn.GELU, norm_layer=nn.LayerNorm, + window_size=None, attn_head_dim=None): + super().__init__() + self.norm1 = norm_layer(dim) + self.attn = Attention( + dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, + attn_drop=attn_drop, proj_drop=drop, window_size=window_size, attn_head_dim=attn_head_dim) + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) + + if init_values is not None: + self.gamma_1 = nn.Parameter(init_values * torch.ones((dim)),requires_grad=True) + self.gamma_2 = nn.Parameter(init_values * torch.ones((dim)),requires_grad=True) + else: + self.gamma_1, self.gamma_2 = None, None + + def forward(self, x, rel_pos_bias=None): + if self.gamma_1 is None: + x = x + self.drop_path(self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias)) + x = x + self.drop_path(self.mlp(self.norm2(x))) + else: + x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias)) + x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x))) + return x + + +class PatchEmbed(nn.Module): + """ Image to Patch Embedding + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) + self.patch_shape = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) + self.img_size = img_size + self.patch_size = patch_size + self.num_patches = num_patches + + self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size) + + def forward(self, x, **kwargs): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) + return x + + +class RelativePositionBias(nn.Module): + + def __init__(self, window_size, num_heads): + super().__init__() + self.window_size = window_size + self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3 + self.relative_position_bias_table = nn.Parameter( + torch.zeros(self.num_relative_distance, num_heads)) # 2*Wh-1 * 2*Ww-1, nH + # cls to token & token 2 cls & cls to cls + + # get pair-wise relative position index for each token inside the window + coords_h = torch.arange(window_size[0]) + coords_w = torch.arange(window_size[1]) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += window_size[0] - 1 # shift to start from 0 + relative_coords[:, :, 1] += window_size[1] - 1 + relative_coords[:, :, 0] *= 2 * window_size[1] - 1 + relative_position_index = \ + torch.zeros(size=(window_size[0] * window_size[1] + 1,) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = self.num_relative_distance - 3 + relative_position_index[0:, 0] = self.num_relative_distance - 2 + relative_position_index[0, 0] = self.num_relative_distance - 1 + + self.register_buffer("relative_position_index", relative_position_index) + + def forward(self): + relative_position_bias = \ + self.relative_position_bias_table[self.relative_position_index.view(-1)].view( + self.window_size[0] * self.window_size[1] + 1, + self.window_size[0] * self.window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + return relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + + +class VisionTransformer(nn.Module): + """ Vision Transformer with support for patch or hybrid CNN input stage + """ + def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12, + num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0., + drop_path_rate=0., norm_layer=nn.LayerNorm, init_values=None, + use_abs_pos_emb=True, use_rel_pos_bias=False, use_shared_rel_pos_bias=False, + use_mean_pooling=True, init_scale=0.001): + super().__init__() + self.num_classes = num_classes + self.num_features = self.embed_dim = embed_dim + self.patch_size = patch_size + self.in_chans = in_chans + + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim) + num_patches = self.patch_embed.num_patches + + self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) + if use_abs_pos_emb: + self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim)) + else: + self.pos_embed = None + self.pos_drop = nn.Dropout(p=drop_rate) + + if use_shared_rel_pos_bias: + self.rel_pos_bias = RelativePositionBias(window_size=self.patch_embed.patch_shape, num_heads=num_heads) + else: + self.rel_pos_bias = None + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule + self.use_rel_pos_bias = use_rel_pos_bias + self.blocks = nn.ModuleList([ + Block( + dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale, + drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, + init_values=init_values, window_size=self.patch_embed.patch_shape if use_rel_pos_bias else None) + for i in range(depth)]) + self.norm = nn.Identity() if use_mean_pooling else norm_layer(embed_dim) + self.fc_norm = norm_layer(embed_dim) if use_mean_pooling else None + self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + if self.pos_embed is not None: + self._trunc_normal_(self.pos_embed, std=.02) + self._trunc_normal_(self.cls_token, std=.02) + if num_classes > 0: + self._trunc_normal_(self.head.weight, std=.02) + self.apply(self._init_weights) + self.fix_init_weight() + + if num_classes > 0: + self.head.weight.data.mul_(init_scale) + self.head.bias.data.mul_(init_scale) + + def _trunc_normal_(self, tensor, mean=0., std=1.): + trunc_normal_(tensor, mean=mean, std=std) + + def fix_init_weight(self): + def rescale(param, layer_id): + param.div_(math.sqrt(2.0 * layer_id)) + + for layer_id, layer in enumerate(self.blocks): + rescale(layer.attn.proj.weight.data, layer_id + 1) + rescale(layer.mlp.fc2.weight.data, layer_id + 1) + + def _init_weights(self, m): + if isinstance(m, nn.Linear): + self._trunc_normal_(m.weight, std=.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + elif isinstance(m, nn.LayerNorm): + nn.init.constant_(m.bias, 0) + nn.init.constant_(m.weight, 1.0) + elif isinstance(m, nn.Conv2d): + self._trunc_normal_(m.weight, std=.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def get_num_layers(self): + return len(self.blocks) + + @torch.jit.ignore + def no_weight_decay(self): + return {'pos_embed', 'cls_token'} + + def get_classifier(self): + return self.head + + def reset_classifier(self, num_classes, global_pool=''): + self.num_classes = num_classes + self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity() + + def forward_features(self, x): + x = self.patch_embed(x) + batch_size, seq_len, _ = x.size() + + cls_tokens = self.cls_token.expand(batch_size, -1, -1) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + if self.pos_embed is not None: + x = x + self.pos_embed + x = self.pos_drop(x) + + rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None + for blk in self.blocks: + x = blk(x, rel_pos_bias=rel_pos_bias) + + x = self.norm(x) + if self.fc_norm is not None: + t = x[:, 1:, :] + return self.fc_norm(t.mean(1)) + else: + return x[:, 0] + + def forward(self, x): + x = self.forward_features(x) + x = self.head(x) + return x + + +def build_vit(config): + model = VisionTransformer( + img_size=config.DATA.IMG_SIZE, + patch_size=config.MODEL.VIT.PATCH_SIZE, + in_chans=config.MODEL.VIT.IN_CHANS, + num_classes=config.MODEL.NUM_CLASSES, + embed_dim=config.MODEL.VIT.EMBED_DIM, + depth=config.MODEL.VIT.DEPTH, + num_heads=config.MODEL.VIT.NUM_HEADS, + mlp_ratio=config.MODEL.VIT.MLP_RATIO, + qkv_bias=config.MODEL.VIT.QKV_BIAS, + drop_rate=config.MODEL.DROP_RATE, + drop_path_rate=config.MODEL.DROP_PATH_RATE, + norm_layer=partial(nn.LayerNorm, eps=1e-6), + init_values=config.MODEL.VIT.INIT_VALUES, + use_abs_pos_emb=config.MODEL.VIT.USE_APE, + use_rel_pos_bias=config.MODEL.VIT.USE_RPB, + use_shared_rel_pos_bias=config.MODEL.VIT.USE_SHARED_RPB, + use_mean_pooling=config.MODEL.VIT.USE_MEAN_POOLING) + + return model \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/optimizer.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..45bbeaed4927cf86b06619ca435a53db9526af07 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/optimizer.py @@ -0,0 +1,191 @@ +# -------------------------------------------------------- +# SimMIM +# Copyright (c) 2021 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Ze Liu +# Modified by Zhenda Xie +# -------------------------------------------------------- + +import json +from functools import partial +from torch import optim as optim + + +def build_optimizer(config, model, logger, is_pretrain): + if is_pretrain: + return build_pretrain_optimizer(config, model, logger) + else: + return build_finetune_optimizer(config, model, logger) + + +def build_pretrain_optimizer(config, model, logger): + logger.info('>>>>>>>>>> Build Optimizer for Pre-training Stage') + skip = {} + skip_keywords = {} + if hasattr(model, 'no_weight_decay'): + skip = model.no_weight_decay() + logger.info(f'No weight decay: {skip}') + if hasattr(model, 'no_weight_decay_keywords'): + skip_keywords = model.no_weight_decay_keywords() + logger.info(f'No weight decay keywords: {skip_keywords}') + + parameters = get_pretrain_param_groups(model, logger, skip, skip_keywords) + + opt_lower = config.TRAIN.OPTIMIZER.NAME.lower() + optimizer = None + if opt_lower == 'sgd': + optimizer = optim.SGD(parameters, momentum=config.TRAIN.OPTIMIZER.MOMENTUM, nesterov=True, + lr=config.TRAIN.BASE_LR, weight_decay=config.TRAIN.WEIGHT_DECAY) + elif opt_lower == 'adamw': + optimizer = optim.AdamW(parameters, eps=config.TRAIN.OPTIMIZER.EPS, betas=config.TRAIN.OPTIMIZER.BETAS, + lr=config.TRAIN.BASE_LR, weight_decay=config.TRAIN.WEIGHT_DECAY) + + logger.info(optimizer) + return optimizer + + +def get_pretrain_param_groups(model, logger, skip_list=(), skip_keywords=()): + has_decay = [] + no_decay = [] + has_decay_name = [] + no_decay_name = [] + + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + if len(param.shape) == 1 or name.endswith(".bias") or (name in skip_list) or \ + check_keywords_in_name(name, skip_keywords): + no_decay.append(param) + no_decay_name.append(name) + else: + has_decay.append(param) + has_decay_name.append(name) + logger.info(f'No decay params: {no_decay_name}') + logger.info(f'Has decay params: {has_decay_name}') + return [{'params': has_decay}, + {'params': no_decay, 'weight_decay': 0.}] + + +def build_finetune_optimizer(config, model, logger): + logger.info('>>>>>>>>>> Build Optimizer for Fine-tuning Stage') + if config.MODEL.TYPE == 'swin': + depths = config.MODEL.SWIN.DEPTHS + num_layers = sum(depths) + get_layer_func = partial(get_swin_layer, num_layers=num_layers + 2, depths=depths) + elif config.MODEL.TYPE == 'vit': + num_layers = config.MODEL.VIT.DEPTH + get_layer_func = partial(get_vit_layer, num_layers=num_layers + 2) + else: + raise NotImplementedError + + scales = list(config.TRAIN.LAYER_DECAY ** i for i in reversed(range(num_layers + 2))) + + skip = {} + skip_keywords = {} + if hasattr(model, 'no_weight_decay'): + skip = model.no_weight_decay() + logger.info(f'No weight decay: {skip}') + if hasattr(model, 'no_weight_decay_keywords'): + skip_keywords = model.no_weight_decay_keywords() + logger.info(f'No weight decay keywords: {skip_keywords}') + + parameters = get_finetune_param_groups( + model, logger, config.TRAIN.BASE_LR, config.TRAIN.WEIGHT_DECAY, + get_layer_func, scales, skip, skip_keywords) + + opt_lower = config.TRAIN.OPTIMIZER.NAME.lower() + optimizer = None + if opt_lower == 'sgd': + optimizer = optim.SGD(parameters, momentum=config.TRAIN.OPTIMIZER.MOMENTUM, nesterov=True, + lr=config.TRAIN.BASE_LR, weight_decay=config.TRAIN.WEIGHT_DECAY) + elif opt_lower == 'adamw': + optimizer = optim.AdamW(parameters, eps=config.TRAIN.OPTIMIZER.EPS, betas=config.TRAIN.OPTIMIZER.BETAS, + lr=config.TRAIN.BASE_LR, weight_decay=config.TRAIN.WEIGHT_DECAY) + + logger.info(optimizer) + return optimizer + + +def get_vit_layer(name, num_layers): + if name in ("cls_token", "mask_token", "pos_embed"): + return 0 + elif name.startswith("patch_embed"): + return 0 + elif name.startswith("rel_pos_bias"): + return num_layers - 1 + elif name.startswith("blocks"): + layer_id = int(name.split('.')[1]) + return layer_id + 1 + else: + return num_layers - 1 + + +def get_swin_layer(name, num_layers, depths): + if name in ("mask_token"): + return 0 + elif name.startswith("patch_embed"): + return 0 + elif name.startswith("layers"): + layer_id = int(name.split('.')[1]) + block_id = name.split('.')[3] + if block_id == 'reduction' or block_id == 'norm': + return sum(depths[:layer_id + 1]) + layer_id = sum(depths[:layer_id]) + int(block_id) + return layer_id + 1 + else: + return num_layers - 1 + + +def get_finetune_param_groups(model, logger, lr, weight_decay, get_layer_func, scales, skip_list=(), skip_keywords=()): + parameter_group_names = {} + parameter_group_vars = {} + + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + if len(param.shape) == 1 or name.endswith(".bias") or (name in skip_list) or \ + check_keywords_in_name(name, skip_keywords): + group_name = "no_decay" + this_weight_decay = 0. + else: + group_name = "decay" + this_weight_decay = weight_decay + if get_layer_func is not None: + layer_id = get_layer_func(name) + group_name = "layer_%d_%s" % (layer_id, group_name) + else: + layer_id = None + + if group_name not in parameter_group_names: + if scales is not None: + scale = scales[layer_id] + else: + scale = 1. + + parameter_group_names[group_name] = { + "group_name": group_name, + "weight_decay": this_weight_decay, + "params": [], + "lr": lr * scale, + "lr_scale": scale, + } + parameter_group_vars[group_name] = { + "group_name": group_name, + "weight_decay": this_weight_decay, + "params": [], + "lr": lr * scale, + "lr_scale": scale + } + + parameter_group_vars[group_name]["params"].append(param) + parameter_group_names[group_name]["params"].append(name) + logger.info("Param groups = %s" % json.dumps(parameter_group_names, indent=2)) + return list(parameter_group_vars.values()) + + +def check_keywords_in_name(name, keywords=()): + isin = False + for keyword in keywords: + if keyword in name: + isin = True + return isin \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/readme.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..30fb96f84ecc2b56b36fd73fc8f0a9f650b10cac --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/readme.md @@ -0,0 +1,198 @@ +# Human Anomaly Dataset and Training Framework + +This part provides an open-source dataset and training framework for Human Anomaly Detection. +--- + +## Data Structure + +The dataset and related resources are organized as follows: + +``` +VBench-2.0_human_anomaly_root/ +├── dataset/ # Main directory for the image dataset +│ ├── all_images.zip # Compressed file containing all images +│ ├── face_train.jsonl # Face training set annotations +│ ├── face_test.jsonl # Face testing set annotations +│ ├── hand_train.jsonl # Hand training set annotations +│ ├── hand_test.jsonl # Hand testing set annotations +│ ├── human_train.jsonl # Human training set annotations +│ ├── human_test.jsonl # Human testing set annotations +├── src_video/ # Raw video data used to construct the dataset +│ ├── CogVideo/ # Videos generated by CogVideoX-1.5 +│ ├── CogVideo-1.0/ # Videos generated by CogVideoX-1.0 +│ ├── vad_real/ # Real-world videos +``` + +Each JSONL file contains annotations for the corresponding images. Each line in the JSONL file represents a single sample in the following format: +```json +["image_filename.jpg", label, score] +``` + +- `image_filename.jpg`: The base name of the image file. +- `label`: The ground truth label (e.g., class or pose information). +- `score`: Confidence score (unused). + +--- + +## Framework + +### Data Pre-processing for training and inference + +- We first use YOLO-World as the open-vocaburary detector to detect the human in each frame, then detect the face and hand from the croped human image. The detection threshold is set to 0.1. +- To meet the input size requirement (square) of SimMIM, we extend the bounding boxes into square. +- The human, face, hand will be saved to different folders for the following three anomaly detectors. +- We show the data processing pipeline below. +

+ +

+ +### Training Pipeline + +- We utilize the pre-trained weight of SimMIM and finetune the whole network with an additional anomaly detector that consists of a MLP layer. +- For the anomaly score, 0 means the image is normal and 1 means the image is abnormal, we use the binary cross entropy loss. +- The human, human face and human hand anomaly detectors need to be trained separately, the higher the score, the more possible it is an anomaly. +- We show the training pipeline below. +

+ +

+ +### Inference Pipeline + +- Given a generated video, we do frame-wise anomaly detection. +- Firstly, we detect and crop the human, human face and hand by YOLO-World as shown in ``data pre-processing`` in each frame. +- Then the detected image will be fed into corresponding anomaly detector with different anomaly threshold (i.e., 0.45, 0.3, 0.32 for human, human face, and human hands respectively). +- For each frame, we calculate the average score of the anomaly score of each human (sometimes there is more than one person in the frame). +- For each human, it is flagged as abnormal if any of the three models predict an anomaly and the score will be 0, otherwise 1. +--- + +## How to Train + +### Prerequisites +- Follow VBench2.0 environment set-up + +### Steps to Train + +1. **Download Pre-trained Model**: + - Download the pre-trained SimMIM model from [Google Drive](https://drive.google.com/file/d/1dJn6GYkwMIcoP3zqOEyW1_iQfpBi8UOw/view?usp=sharing) + - Download the pre-trained YOLO-World model from [Google Drive](https://drive.google.com/file/d/1qo-K1kum7yiEwIlN1TWDvABXX6qriUen/view?usp=drive_link) + - put the models into `pretrain/` + - or use the following command: + ```bash + gdown https://drive.google.com/uc?id=1dJn6GYkwMIcoP3zqOEyW1_iQfpBi8UOw -O pretrain/ + gdown https://drive.google.com/uc?id=1qo-K1kum7yiEwIlN1TWDvABXX6qriUen -O pretrain/ + ``` + +2. **Download Dataset**: + - Download the dataset files from [Google Drive](https://drive.google.com/drive/folders/1_NyiLa861EbDQdDp4Lsy4jTzH2ynCiFw?usp=drive_link) or the following URL: + ```bash + git clone https://huggingface.co/datasets/Vchitect/VBench-2.0_human_anomaly + ``` + - If the large folder does not download, use the following command (You need to configure Git LFS in advance, or we suggest using the Google Drive link above.): + ```bash + cd "VBench-2.0_human_anomaly" + git lfs install + git lfs pull + ``` + +3. **Extract Images**: + - Unzip the `opensource.zip` file: + ```bash + cd "VBench-2.0_human_anomaly" + zip -s 0 --out merged.zip "opensource.zip" + unzip merged.zip + mv opensource/* ./ + rm -rf opensource + rm merged.zip + rm opensource.* + ``` + +4. **Run Training**: + - Execute the training code (we take face detector training as an example, for human and hand detectors, change the corresponding names): + ```python + torchrun --master_port 15690 main_finetune.py \ + --cfg 'configs/vit_base__800ep/simmim_finetune__vit_base__img224__800ep.yaml' \ + --train-path "VBench-2.0_human_anomaly/dataset/face_train.jsonl" \ + --val-path "VBench-2.0_human_anomaly/dataset/face_test.jsonl" \ + --pretrained 'pretrain/simmim_pretrain__vit_base__img224__800ep.pth' \ + --batch-size 128 \ + --output "checkpoint/face" + ``` + + +5. **Run Inference**: + - Note that you need to train all of the three detectors to run the inference code (By default, we train for 30 epochs): + ```python + python inference.py \ + --cfg 'configs/vit_base__800ep/simmim_finetune__vit_base__img224__800ep.yaml' \ + --detector_config 'third_party/YOLO-World/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py' \ + --detector_weights 'pretrain/yolo_world_v2_xl_obj365v1_goldg_cc3mlite_pretrain-5daf1395.pth' \ + --human_model 'checkpoint/human/ckpt29.pth' \ + --face_model 'checkpoint/face/ckpt29.pth' \ + --hand_model 'checkpoint/hand/ckpt29.pth' + ``` + +### Notes +- Ensure that all paths in the JSONL files correctly point to the extracted images. +- Modify the configuration file (`config.yaml` or similar) if you wish to customize training parameters. + + +### Results +- We show some results of our anomaly detector below +

+ +

+More Cases +

+ +

+

+ +

+ + +## :black_nib: Citation + + If you find our repo useful for your research, please consider citing our paper: + + ```bibtex + @article{zheng2025vbench2, + title={{VBench-2.0}: Advancing Video Generation Benchmark Suite for Intrinsic Faithfulness}, + author={Zheng, Dian and Huang, Ziqi and Liu, Hongbo and Zou, Kai and He, Yinan and Zhang, Fan and Zhang, Yuanhan and He, Jingwen and Zheng, Wei-Shi and Qiao, Yu and Liu, Ziwei}, + journal={arXiv preprint arXiv:2503.21755}, + year={2025} + } + + @InProceedings{huang2023vbench, + title={{VBench}: Comprehensive Benchmark Suite for Video Generative Models}, + author={Huang, Ziqi and He, Yinan and Yu, Jiashuo and Zhang, Fan and Si, Chenyang and Jiang, Yuming and Zhang, Yuanhan and Wu, Tianxing and Jin, Qingyang and Chanpaisit, Nattapol and Wang, Yaohui and Chen, Xinyuan and Wang, Limin and Lin, Dahua and Qiao, Yu and Liu, Ziwei}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition}, + year={2024} + } + + @article{huang2025vbench++, + title={{VBench++}: Comprehensive and Versatile Benchmark Suite for Video Generative Models}, + author={Huang, Ziqi and Zhang, Fan and Xu, Xiaojie and He, Yinan and Yu, Jiashuo and Dong, Ziyue and Ma, Qianli and Chanpaisit, Nattapol and Si, Chenyang and Jiang, Yuming and Wang, Yaohui and Chen, Xinyuan and Chen, Ying-Cong and Wang, Limin and Lin, Dahua and Qiao, Yu and Liu, Ziwei}, + journal={IEEE Transactions on Pattern Analysis and Machine Intelligence}, + year={2025}, + doi={10.1109/TPAMI.2025.3633890} + } + + ``` + + +## :hearts: Acknowledgement + +**VBench-2.0** is currently maintained by [Dian Zheng](https://zhengdian1.github.io/), [Ziqi Huang](https://ziqihuangg.github.io/) and [Kai Zou](https://github.com/Jacky-hate). + +#### :hugs: Open-Sourced Repositories +This project wouldn't be possible without the following open-sourced repositories: [YOLO_World](https://github.com/AILab-CVC/YOLO-World), [SimMIM](https://github.com/microsoft/SimMIM) + +--- + +## License + +This project is released under the [MIT License](LICENSE). You are free to use, modify, and distribute the dataset and code for academic and commercial purposes, provided you include proper attribution. + +--- + + diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/simmim_finetune__vit_base__img224__800ep.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/simmim_finetune__vit_base__img224__800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..13f584bf9449fd38166bbfb4f1b1334ccbff2e93 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/simmim_finetune__vit_base__img224__800ep.yaml @@ -0,0 +1,25 @@ +MODEL: + TYPE: vit + NAME: simmim_finetune + DROP_PATH_RATE: 0.1 + VIT: + EMBED_DIM: 768 + DEPTH: 12 + NUM_HEADS: 12 + USE_APE: False + USE_RPB: True + USE_SHARED_RPB: False + USE_MEAN_POOLING: True +DATA: + IMG_SIZE: 224 +TRAIN: + EPOCHS: 30 + WARMUP_EPOCHS: 3 + BASE_LR: 1.25e-3 + WARMUP_LR: 2.5e-7 + MIN_LR: 2.5e-7 + WEIGHT_DECAY: 0.05 + LAYER_DECAY: 0.65 +PRINT_FREQ: 2 +SAVE_FREQ: 5 +TAG: simmim_finetune__vit_base__img224__800ep diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/README.md new file mode 100644 index 0000000000000000000000000000000000000000..954d64a5f593f0f984f6ddcf5c6cd96168b7179e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/README.md @@ -0,0 +1,29 @@ +## Fine-tune YOLO-World on MS-COCO + + +### Updates + +1. [2024-3-27]: Considering that fine-tuning YOLO-World on COCO **without `mask-refine`** obtains bad results, e.g., YOLO-World-L obtains 48.6 AP without `mask-refine` compared to 53.3 AP with `mask-refine`, we rethink the training process and explore new training schemes for fine-tuning without `mask-refine`. +BTW, the COCO fine-tuning results are updated with higher performance (with `mask-refine`)! + + +### COCO Results and Checkpoints + +**NOTE:** +1. APZS: AP evaluated in the zero-shot setting (w/o fine-tuning on COCO dataset). +2. `mask-refine`: refine the box annotations with masks, and add `CopyPaste` augmentation during training. + +| model | Schedule | `mask-refine` | efficient neck | APZS| AP | AP50 | AP75 | weights | log | +| :---- | :-------: | :----------: |:-------------: | :------------: | :-: | :--------------:| :-------------: |:------: | :-: | +| [YOLO-World-v2-S](./yolo_world_v2_s_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py) | AdamW, 2e-4, 80e | ✔️ | ✖️ | 37.5 | 46.1 | 62.0 | 49.9 | [HF Checkpoints](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_s_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_ep80-492dc329.pth) | [log](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_s_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_20240327_110411.log) | +| [YOLO-World-v2-M](./yolo_world_v2_m_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py) | AdamW, 2e-4, 80e | ✔️ | ✖️ | 42.8 | 51.0 | 67.5 | 55.2 | [HF Checkpoints](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_m_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_ep80-69c27ac7.pth) | [log](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_m_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_20240327_110411.log) | +| [YOLO-World-v2-L](./yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py) | AdamW, 2e-4, 80e | ✔️ | ✖️ | 45.1 | 53.9 | 70.9 | 58.8 | [HF Checkpoints](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_ep80-81c701ee.pth) | [log](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_20240326_160313.log) | +| [YOLO-World-v2-X](./yolo_world_v2_x_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py) | AdamW, 2e-4, 80e | ✔️ | ✖️ | 46.8 | 54.7 | 71.6 | 59.6 | [HF Checkpoints](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_x_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_ep80-76bc0cbd.pth) | [log](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_x_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco_20240322_181232.log) | +| [YOLO-World-v2-L](./yolo_world_v2_l_vlpan_bn_sgd_1e-3_40e_8gpus_finetune_coco.py) 🔥 | SGD, 1e-3, 40e | ✖️ | ✖️ | 45.1 | 52.8 | 69.5 | 57.8 | [HF Checkpoints](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_l_vlpan_bn_sgd_1e-3_40e_8gpus_finetune_coco_ep80-e1288152.pth) | [log](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_v2_l_vlpan_bn_sgd_1e-3_40e_8gpus_finetuning_coco_20240327_014902.log) | + + +### Reparameterized Training + +| model | Schedule | `mask-refine` | efficient neck | APZS| AP | AP50 | AP75 | weights | log | +| :---- | :-------: | :----------: |:-------------: | :------------: | :-: | :--------------:| :-------------: |:------: | :-: | +| [YOLO-World-v2-S](./yolo_world_v2_s_rep_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py) | AdamW, 2e-4, 80e | ✔️ | ✖️ | 37.5 | 46.3 | 62.8 | 50.4 | [HF Checkpoints]() | [log]() | \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_dual_vlpan_2e-4_80e_8gpus_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_dual_vlpan_2e-4_80e_8gpus_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..101a571dbf6a6c79d50c37dff98a2ac0698e91b7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_dual_vlpan_2e-4_80e_8gpus_finetune_coco.py @@ -0,0 +1,179 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from='pretrained_models/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-0e566235.pth' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_dual_vlpan_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_dual_vlpan_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..2ddbe50d4c63d7cd5953f9f096b57661ccb2f287 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_dual_vlpan_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,181 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from='pretrained_models/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-0e566235.pth' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_efficient_neck_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_efficient_neck_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b5cdca5069b2a76915b80d64e02fc0a44840899e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_l_efficient_neck_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,159 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-0e566235.pth' +# huggingface text model +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='EfficientCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *text_transform +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +coco_train_dataset = dict(_delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, + min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_efficient_neck_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_efficient_neck_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b8a50ad21609bd110dc4fe4d8f7109a140f2f12a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_efficient_neck_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,182 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='EfficientCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf1da23e372d3dfd89e5f6833e3369ddae2404c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,181 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_40e_8gpus_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_40e_8gpus_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8bb4fce3051662d330637570e79dac966c4590f4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_40e_8gpus_finetune_coco.py @@ -0,0 +1,160 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 40 # Maximum training epochs +close_mosaic_epochs = 30 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 1e-3 +weight_decay = 0.0005 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict(type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict(type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *text_transform +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] + +coco_train_dataset = dict(_delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, + min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='SGD', + lr=base_lr, + momentum=0.937, + nesterov=True, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={ + 'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..1b0bf75fc3c08ebfca49ea6a26c85fd113266a8c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,161 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 1e-3 +weight_decay = 0.0005 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict(type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict(type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *text_transform +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +coco_train_dataset = dict(_delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, + min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='SGD', + lr=base_lr, + momentum=0.937, + nesterov=True, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={ + 'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_m_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_m_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..32fcc51cdffc459a3d11461174a989e6e3438688 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_m_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,182 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_m_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_train-c6237d5b.pth' +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..498011019471f55cf525802c44bbc865f9a67655 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,145 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = '../FastDet/output_models/pretrain_yolow-v8_s_clipv2_frozen_te_noprompt_t2i_bn_2e-3adamw_scale_lr_wd_32xb16-100e_obj365v1_goldg_cc3mram250k_train_lviseval-e3592307_rep_conv.pth' +persistent_workers = False +mixup_prob = 0.15 +copypaste_prob = 0.3 + +# model settings +model = dict(type='SimpleYOLOWorldDetector', + mm_neck=True, + num_train_classes=num_classes, + num_test_classes=num_classes, + reparameterized=True, + data_preprocessor=dict(type='YOLOv5DetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + text_model=None, + image_model={{_base_.model.backbone}}, + with_text_model=False), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='EfficientCSPLayerWithTwoConv')), + bbox_head=dict(head_module=dict(type='RepYOLOWorldHeadModule', + embed_dims=text_channels, + num_guide=num_classes, + num_classes=num_classes)), + train_cfg=dict(assigner=dict(num_classes=num_classes))) + +# dataset settings +final_transform = [ + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +mosaic_affine_transform = [ + dict(type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *final_transform +] + +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *final_transform] + +coco_train_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +coco_val_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=test_pipeline) + +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_rep_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_rep_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..9fe682c87edc1c1c7c8e6d10f2c08e5f819b501f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_rep_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,146 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = '../FastDet/output_models/yolo_world_s_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_train-55b943ea_rep_conv.pth' +persistent_workers = False +mixup_prob = 0.15 +copypaste_prob = 0.3 + +# model settings +model = dict(type='SimpleYOLOWorldDetector', + mm_neck=True, + num_train_classes=num_classes, + num_test_classes=num_classes, + reparameterized=True, + data_preprocessor=dict(type='YOLOv5DetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + text_model=None, + image_model={{_base_.model.backbone}}, + with_text_model=False), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=num_classes, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='RepConvMaxSigmoidCSPLayerWithTwoConv', + guide_channels=num_classes)), + bbox_head=dict(head_module=dict(type='RepYOLOWorldHeadModule', + embed_dims=text_channels, + num_guide=num_classes, + num_classes=num_classes)), + train_cfg=dict(assigner=dict(num_classes=num_classes))) + +# dataset settings +final_transform = [ + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +mosaic_affine_transform = [ + dict(type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *final_transform +] + +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *final_transform] + +coco_train_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +coco_val_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=test_pipeline) + +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..1cacd5d12020f63d26020ab6782ac72e0a98e81c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_s_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,184 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_s_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_train-55b943ea.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False +mixup_prob = 0.15 +copypaste_prob = 0.3 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_x_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_x_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..e78c5f312ab52cfd87a238b2bf6447d3cf18c4e2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_x_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,183 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict( + imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_x_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc250k_train_lviseval-8698fbfa.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict( + type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, + *mosaic_affine_transform, + dict( + type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, + *mosaic_affine_transform]), + *_base_.last_transform[:-1], + *text_transform +] +train_pipeline_stage2 = [ + *_base_.train_pipeline_stage2[:-1], + *text_transform +] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict( + persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict( + param_scheduler=dict( + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict( + max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict( + optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0)}), + constructor='YOLOWv5OptimizerConstructor') +# evaluation settings +val_evaluator = dict( + _delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_xl_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_xl_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..125659b8cb5597c077e9a623cca16876167b6217 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/finetune_coco/yolo_world_v2_xl_vlpan_bn_2e-4_80e_8gpus_mask-refine_finetune_coco.py @@ -0,0 +1,173 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# scaling model from X to XL +deepen_factor = 1.0 +widen_factor = 1.5 + +backbone = _base_.model.backbone +backbone.update(deepen_factor=deepen_factor, widen_factor=widen_factor) + +# model settings +model = dict(type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + image_model=backbone, + text_model=dict(type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + widen_factor=widen_factor, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *text_transform +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +coco_train_dataset = dict(_delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, + min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/image_prompts/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_image_prompt_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/image_prompts/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_image_prompt_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..65b15454f2ba7372f84abe9c33aed1c7ae1b440d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/image_prompts/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_image_prompt_demo.py @@ -0,0 +1,127 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +persistent_workers = False +text_model_name = '../pretrained_models/open-ai-clip-vit-base-patch32' +img_scale = (800, 800) + +# model settings +model = dict(type='YOLOWorldImageDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + vision_model=text_model_name, + prompt_dim=text_channels, + data_preprocessor=dict(type='YOLOv5DetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + frozen_stages=4, + text_model=dict(type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + freeze_all=True, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +coco_train_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict( + type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/coco_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=_base_.train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) + +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict( + custom_keys={ + 'backbone.text_model': dict(lr_mult=0.01), + 'logit_scale': dict(weight_decay=0.0), + 'embeddings': dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_clip_large_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_800ft_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_clip_large_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_800ft_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..16067a6880b0e21f0b6ec06c98cf02626bec552e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_clip_large_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_800ft_lvis_minival.py @@ -0,0 +1,200 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 768 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.0125 +train_batch_size_per_gpu = 16 +# text_model_name = '../pretrained_models/clip-vit-large-patch14-336' +text_model_name = 'openai/clip-vit-large-patch14-336' +img_scale = (800, 800) + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] + +train_pipeline_stage2 = [ + *_base_.pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform +] + +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_clip_large_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_clip_large_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..b5b84ab7a6724d25a0fb0678ed0f2f5f566afb1a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_clip_large_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,171 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 768 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.0125 +train_batch_size_per_gpu = 16 +# text_model_name = '../pretrained_models/clip-vit-large-patch14-336' +text_model_name = 'openai/clip-vit-large-patch14-336' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..a2b527c55204ae7791108ba4f4ae6824e478a824 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py @@ -0,0 +1,202 @@ +_base_ = ('VBench2.0/third_party/YOLO-World/third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 20 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.025 +train_batch_size_per_gpu = 4 +load_from = "pretrained_models/yolo_world_v2_l_obj365v1_goldg_pretrain-a82b1fe3.pth" +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +img_scale = (1280, 1280) + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] + +train_pipeline_stage2 = [ + *_base_.pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform +] + +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='third_party/YOLO-World/data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='third_party/YOLO-World/data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='third_party/YOLO-World/data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='third_party/YOLO-World/data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) + +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..cb8beec0af6f0fc4b0642f2f6fca4462e44eae60 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,171 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_val.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_val.py new file mode 100644 index 0000000000000000000000000000000000000000..70b19b287e03ea84131f9b8911b761f7eeaaa77e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_val.py @@ -0,0 +1,171 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..59507204a06baa6c0a6302f52e3c73f9602044c6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py @@ -0,0 +1,198 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_m_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +img_scale = (1280, 1280) + +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] + +train_pipeline_stage2 = [ + *_base_.pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform +] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..906336cd8da5ffdde4c99bd4ff75bc9e7b03aa13 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,171 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_m_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +text_model_name = 'openai/clip-vit-large-patch14-336' +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_noeinsum_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_noeinsum_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..264b026ca780dffc91236cf53908858488337541 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_m_vlpan_bn_noeinsum_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,176 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_m_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv', + use_einsum=False)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes, + use_einsum=False)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] + +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] + +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_s_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_s_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..3afb76aa8aab584a99c623926b5a363c1a453d89 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_s_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py @@ -0,0 +1,195 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_s_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.025 +train_batch_size_per_gpu = 4 +img_scale = (1280, 1280) + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [ + *_base_.pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform +] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_s_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_s_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..775cc8e7867e60f4fad8d24d492d982b3463e697 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_s_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,170 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_s_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_cc3mlite_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_cc3mlite_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..a2ba421e89b39db1bf1c64ba6ffe6b3f2575e542 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_cc3mlite_train_lvis_minival.py @@ -0,0 +1,183 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + + +cc3m_train_dataset = dict(type='YOLOv5GeneralGroundingDataset', + data_root='data/cc3m/', + ann_file='annotations/cc3m_pseudo_annotations.json', + data_prefix=dict(img='training'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, + mg_train_dataset, + cc3m_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..ab4cd23f4628950bd31b01422f92a0a3ee50c683 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py @@ -0,0 +1,199 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +# text_model_name = 'openai/clip-vit-base-patch32' +img_scale = (1280, 1280) + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [ + *_base_.pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform +] + +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..e3c1226d6f10bd785a03eeccf1a669f9f6531062 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,171 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..35977e8ed93ee68ef96a9a2b98ebe02d4c18abf8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain/yolo_world_v2_xl_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,185 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' + +# scaling model from X to XL +deepen_factor = 1.0 +widen_factor = 1.5 + +backbone = _base_.model.backbone +backbone.update( + deepen_factor=deepen_factor, + widen_factor=widen_factor +) + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model=backbone, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + widen_factor=widen_factor, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3290c7e0f7ab6b3bd10dd5b0ecaa5371d723f915 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/README.md @@ -0,0 +1,21 @@ +## Pre-training YOLO-World-v1 + +> The YOLO-World-v1 is an initial version, and now is nearly deprecated! We strongly suggest you use the [latest version](../pretrain/). + + + +### Zero-shot Inference on LVIS dataset + +| model | Pre-train Data | Size | APmini | APr | APc | APf | APval | APr | APc | APf | weights | +| :------------------------------------------------------------------------------------------------------------------- | :------------------- | :----------------- | :--------------: | :------------: | :------------: | :------------: | :-------------: | :------------: | :------------: | :------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [YOLO-World-S](./yolo_world_s_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py) | O365+GoldG | 640 | 24.3 | 16.6 | 22.1 | 27.7 | 17.8 | 11.0 | 14.8 | 24.0 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/resolve/main/yolo_world_s_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-18bea4d2.pth) | +| [YOLO-World-M](./yolo_world_m_dual_l2norm_2e-4_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py) | O365+GoldG | 640 | 28.6 | 19.7 | 26.6 | 31.9 | 22.3 | 16.2 | 19.0 | 28.7 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/resolve/main/yolo_world_m_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-2b7bd1be.pth) | +| [YOLO-World-L](./yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py) | O365+GoldG | 640 | 32.5 | 22.3 | 30.6 | 36.1 | 24.8 | 17.8 | 22.4 | 32.5 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/resolve/main/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-0e566235.pth) | +| [YOLO-World-L](./yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py) | O365+GoldG+CC3M-Lite | 640 | 33.0 | 23.6 | 32.0 | 35.5 | 25.3 | 18.0 | 22.1 | 32.1 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_cc3mlite_train_pretrained-7a5eea3b.pth) | +| [YOLO-World-X](./yolo_world_x_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py) | O365+GoldG+CC3M-Lite | 640 | 33.4 | 24.4 | 31.6 | 36.6 | 26.6 | 19.2 | 23.5 | 33.2 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_x_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_cc3mlite_train_pretrained-8cf6b025.pth) | + + +**NOTE:** +1. APmini: evaluated on LVIS `minival`. +3. APval: evaluated on LVIS `val 1.0`. +4. [HuggingFace Mirror](https://hf-mirror.com/) provides the mirror of HuggingFace, which is a choice for users who are unable to reach. \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..e88be2eb6f54cb19d066974548ea08239ac4127f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,172 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_val.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_val.py new file mode 100644 index 0000000000000000000000000000000000000000..66333b10916d3e971d4d3c9e968ab91b48f28022 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_l_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_val.py @@ -0,0 +1,172 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_m_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_m_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..18c3be69dca57df960b428e46800fb7543d2c1da --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_m_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,172 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_m_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_s_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_s_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..5441d0ff995889f9ebcef97c853daf69dbbc4564 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_s_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,172 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_s_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_x_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_x_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py new file mode 100644 index 0000000000000000000000000000000000000000..f20d3f01cb6f3a301e726ed2d3f8e7b32b61f50f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/pretrain_v1/yolo_world_x_dual_vlpan_l2norm_2e-3_100e_4x8gpus_obj365v1_goldg_train_lvis_minival.py @@ -0,0 +1,172 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_x_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], + allow_failed_imports=False) + +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 100 # Maximum training epochs +close_mosaic_epochs = 2 +save_epoch_intervals = 2 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 / 2 +train_batch_size_per_gpu = 16 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict(type='YOLOWorldHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +train_pipeline = [ + *_base_.pre_transform, + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)), + *_base_.last_transform[:-1], + *text_transform, +] +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *text_transform] +obj365v1_train_dataset = dict( + type='MultiModalDataset', + dataset=dict( + type='YOLOv5Objects365V1Dataset', + data_root='data/objects365v1/', + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + class_text_path='data/texts/obj365v1_class_texts.json', + pipeline=train_pipeline) + +mg_train_dataset = dict(type='YOLOv5MixedGroundingDataset', + data_root='data/mixed_grounding/', + ann_file='annotations/final_mixed_train_no_coco.json', + data_prefix=dict(img='gqa/images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +flickr_train_dataset = dict( + type='YOLOv5MixedGroundingDataset', + data_root='data/flickr/', + ann_file='annotations/final_flickr_separateGT_train.json', + data_prefix=dict(img='full_images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=dict(_delete_=True, + type='ConcatDataset', + datasets=[ + obj365v1_train_dataset, + flickr_train_dataset, mg_train_dataset + ], + ignore_keys=['classes', 'palette'])) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_minival_inserted_image_name.json', + metric='bbox') +test_evaluator = val_evaluator + +# training settings +default_hooks = dict(param_scheduler=dict(max_epochs=max_epochs), + checkpoint=dict(interval=save_epoch_intervals, + rule='greater')) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/READEME.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/READEME.md new file mode 100644 index 0000000000000000000000000000000000000000..2888d1bf2ecb14d8f5d903d6aa0be38006bae204 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/READEME.md @@ -0,0 +1,12 @@ +## Prompt Tuning for YOLO-World + +### NOTE: + +This folder contains many experimental config files, which will be removed later!! + +### Experimental Results + +| Model | Config | AP | AP50 | AP75 | APS | APM | APL | +| :---- | :----: | :--: | :--: | :---: | :-: | :-: | :-: | +| YOLO-World-v2-L | Zero-shot | 45.7 | 61.6 | 49.8 | 29.9 | 50.0 | 60.8 | +| [YOLO-World-v2-L](./../configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_prompt_tuning_coco.py) | Prompt tuning | 47.9 | 64.3 | 52.5 | 31.9 | 52.6 | 61.3 | diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_prompt_tuning_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_prompt_tuning_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..3212fa05005d31c01823e103b65792832c4342da --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_mask-refine_prompt_tuning_coco.py @@ -0,0 +1,161 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-3 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +persistent_workers = False + +# model settings +model = dict(type='SimpleYOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + embedding_path='embeddings/clip_vit_b32_coco_80_embeddings.npy', + prompt_dim=text_channels, + num_prompts=80, + data_preprocessor=dict(type='YOLOv5DetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + text_model=None, + image_model={{_base_.model.backbone}}, + frozen_stages=4, + with_text_model=False), + neck=dict(type='YOLOWorldPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + freeze_all=True, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +final_transform = [ + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +mosaic_affine_transform = [ + dict(type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MixUp', + prob=_base_.mixup_prob, + pre_transform=[*_base_.pre_transform, *mosaic_affine_transform]), + *_base_.last_transform[:-1], *final_transform +] + +train_pipeline_stage2 = [*_base_.train_pipeline_stage2[:-1], *final_transform] + +coco_train_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +coco_val_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=test_pipeline) + +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + 'embeddings': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_prompt_tuning_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_prompt_tuning_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..64ce89d13a436d4aa04ed057b60f4586f8b350da --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_2e-4_80e_8gpus_prompt_tuning_coco.py @@ -0,0 +1,117 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 +weight_decay = 0.05 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +persistent_workers = False + +# model settings +model = dict(type='SimpleYOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + embedding_path='embeddings/clip_vit_b32_coco_80_embeddings.npy', + prompt_dim=text_channels, + num_prompts=80, + freeze_prompt=False, + data_preprocessor=dict(type='YOLOv5DetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + text_model=None, + image_model={{_base_.model.backbone}}, + frozen_stages=4, + with_text_model=False), + neck=dict(type='YOLOWorldPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + freeze_all=True, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +coco_train_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +coco_val_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.test_pipeline) + +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=_base_.train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) + +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + 'embeddings': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_80e_8gpus_all_finetuning_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_80e_8gpus_all_finetuning_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8caf5bd70769bfb5a728bb8c6d35448dd1ff9454 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/prompt_tuning_coco/yolo_world_v2_l_vlpan_bn_sgd_1e-3_80e_8gpus_all_finetuning_coco.py @@ -0,0 +1,109 @@ +_base_ = ('../../third_party/mmyolo/configs/yolov8/' + 'yolov8_l_syncbn_fast_8xb16-500e_coco.py') +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) + +# hyper-parameters +num_classes = 80 +num_training_classes = 80 +max_epochs = 40 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 1e-3 +weight_decay = 0.0005 +train_batch_size_per_gpu = 16 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +persistent_workers = False + +# model settings +model = dict(type='SimpleYOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + embedding_path='embeddings/clip_vit_b32_coco_80_embeddings.npy', + prompt_dim=text_channels, + num_prompts=80, + freeze_prompt=True, + data_preprocessor=dict(type='YOLOv5DetDataPreprocessor'), + backbone=dict(_delete_=True, + type='MultiModalYOLOBackbone', + text_model=None, + image_model={{_base_.model.backbone}}, + with_text_model=False), + neck=dict(type='YOLOWorldPAFPN', + freeze_all=False, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldHead', + head_module=dict( + type='YOLOWorldHeadModule', + freeze_all=False, + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes)), + train_cfg=dict(assigner=dict(num_classes=num_training_classes))) + +# dataset settings +coco_train_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.train_pipeline) + +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +coco_val_dataset = dict(type='YOLOv5CocoDataset', + data_root='data/coco', + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.test_pipeline) + +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=_base_.train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) + +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='SGD', + lr=base_lr, + momentum=0.937, + nesterov=True, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu)) + +# evaluation settings +val_evaluator = dict(_delete_=True, + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file='data/coco/annotations/instances_val2017.json', + metric='bbox') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8cfd30341ae20ab7ff9a24fb4df03825d29f0520 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/README.md @@ -0,0 +1,27 @@ +## Fine-tuning YOLO-World for Instance Segmentation + + +### Models + +We fine-tune YOLO-World on LVIS (`LVIS-Base`) with mask annotations for open-vocabulary (zero-shot) instance segmentation. + +We provide two fine-tuning strategies YOLO-World towards open-vocabulary instance segmentation: + +* fine-tuning `all modules`: leads to better LVIS segmentation accuracy but affects the zero-shot performance. + +* fine-tuning the `segmentation head`: maintains the zero-shot performanc but lowers LVIS segmentation accuracy. + +| Model | Fine-tuning Data | Fine-tuning Modules| APmask | APr | APc | APf | Weights | +| :---- | :--------------- | :----------------: | :--------------: | :------------: | :------------: | :------------: | :-----: | +| [YOLO-World-Seg-M](./yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py) | `LVIS-Base` | `all modules` | 25.9 | 13.4 | 24.9 | 32.6 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis-ca465825.pth) | +| [YOLO-World-v2-Seg-M](./yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py) | `LVIS-Base` | `all modules` | 25.9 | 13.4 | 24.9 | 32.6 | [HF Checkpoints 🤗]() | +| [YOLO-World-Seg-L](./yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py) | `LVIS-Base` | `all modules` | 28.7 | 15.0 | 28.3 | 35.2| [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis-8c58c916.pth) | +| [YOLO-World-v2-Seg-L](./yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py) | `LVIS-Base` | `all modules` | 28.7 | 15.0 | 28.3 | 35.2| [HF Checkpoints 🤗]() | +| [YOLO-World-Seg-M](./yolo_seg_world_m_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py) | `LVIS-Base` | `seg head` | 16.7 | 12.6 | 14.6 | 20.8 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis-7bca59a7.pth) | +| [YOLO-World-v2-Seg-M](./yolo_world_v2_seg_m_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py) | `LVIS-Base` | `seg head` | 17.8 | 13.9 | 15.5 | 22.0 | [HF Checkpoints 🤗]() | +| [YOLO-World-Seg-L](yolo_seg_world_l_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py) | `LVIS-Base` | `seg head` | 19.1 | 14.2 | 17.2 | 23.5 | [HF Checkpoints 🤗](https://huggingface.co/wondervictor/YOLO-World/blob/main/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis-5a642d30.pth) | +| [YOLO-World-v2-Seg-L](./yolo_world_v2_seg_l_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py) | `LVIS-Base` | `seg head` | 19.8 | 17.2 | 17.5 | 23.6 | [HF Checkpoints 🤗]() | +**NOTE:** +1. The mask AP are evaluated on the LVIS `val 1.0`. +2. All models are fine-tuned for 80 epochs on `LVIS-Base` (866 categories, `common + frequent`). +3. The YOLO-World-Seg with only `seg head` fine-tuned maintains the original zero-shot detection capability and segments objects. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py new file mode 100644 index 0000000000000000000000000000000000000000..01885dd5461359eb0dd026886268b28449dc6a25 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py @@ -0,0 +1,227 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py' +) +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 + +weight_decay = 0.05 +train_batch_size_per_gpu = 8 +load_from = 'pretrained_models/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-0e566235.pth' +persistent_workers = False +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +# text_model_name = 'openai/clip-vit-base-patch32' +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = False +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=[])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldSegHead', + head_module=dict(type='YOLOWorldSegHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes, + mask_channels=32, + proto_channels=256), + mask_overlap=mask_overlap, + loss_mask=dict(type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none'), + loss_mask_weight=1.0), + train_cfg=dict(assigner=dict(num_classes=num_training_classes)), + test_cfg=dict(mask_thr_binary=0.5, fast_test=True)) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=True) +] + +last_transform = [ + dict(type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict(type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', + 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), +] + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=True) +] +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform, *text_transform +] + +_train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict(type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict(type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] +train_pipeline_stage2 = [*_train_pipeline_stage2, *text_transform] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco', + ann_file='lvis/lvis_v1_train_base.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32)), + class_text_path='data/texts/lvis_v1_base_class_texts.json', + pipeline=train_pipeline) +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/captions/lvis_v1_class_captions.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py new file mode 100644 index 0000000000000000000000000000000000000000..5d4174ab893a289b9f75499f1fe11e43b638ab41 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_l_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py @@ -0,0 +1,237 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py' +) +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 + +weight_decay = 0.05 +train_batch_size_per_gpu = 8 +load_from = 'pretrained_models/yolo_world_l_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-0e566235.pth' +persistent_workers = False + +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = False +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + frozen_stages=4, # frozen the image backbone + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldSegHead', + head_module=dict(type='YOLOWorldSegHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes, + mask_channels=32, + proto_channels=256, + freeze_bbox=True), + mask_overlap=mask_overlap, + loss_mask=dict(type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none'), + loss_mask_weight=1.0), + train_cfg=dict(assigner=dict(num_classes=num_training_classes)), + test_cfg=dict(mask_thr_binary=0.5, fast_test=True)) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=True) +] + +last_transform = [ + dict(type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict(type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', + 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), +] + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=True) +] +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform, *text_transform +] + +_train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict(type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict(type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] +train_pipeline_stage2 = [*_train_pipeline_stage2, *text_transform] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco', + ann_file='lvis/lvis_v1_train_base.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32)), + class_text_path='data/texts/lvis_v1_base_class_texts.json', + pipeline=train_pipeline) +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + 'neck': + dict(lr_mult=0.0), + 'head.head_module.reg_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_contrasts': + dict(lr_mult=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/captions/lvis_v1_class_captions.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py new file mode 100644 index 0000000000000000000000000000000000000000..31331b663551f8f74af41d7efa6f9534dedf9738 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_allmodules_finetune_lvis.py @@ -0,0 +1,226 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py' +) +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 + +weight_decay = 0.05 +train_batch_size_per_gpu = 8 +load_from = 'pretrained_models/yolo_world_m_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-2b7bd1be.pth' +persistent_workers = False + +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = False +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=[])), + neck=dict(type='YOLOWorldDualPAFPN', + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldSegHead', + head_module=dict(type='YOLOWorldSegHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes, + mask_channels=32, + proto_channels=256), + mask_overlap=mask_overlap, + loss_mask=dict(type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none'), + loss_mask_weight=1.0), + train_cfg=dict(assigner=dict(num_classes=num_training_classes)), + test_cfg=dict(mask_thr_binary=0.5, fast_test=True)) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=True) +] + +last_transform = [ + dict(type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict(type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', + 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), +] + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=True) +] +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform, *text_transform +] + +_train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict(type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict(type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] +train_pipeline_stage2 = [*_train_pipeline_stage2, *text_transform] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco', + ann_file='lvis/lvis_v1_train_base.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32)), + class_text_path='data/texts/lvis_v1_base_class_texts.json', + pipeline=train_pipeline) +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/captions/lvis_v1_class_captions.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py new file mode 100644 index 0000000000000000000000000000000000000000..883c3225d4e1bbfbcefe96f9028b9082324c2466 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_seg_m_dual_vlpan_2e-4_80e_8gpus_seghead_finetune_lvis.py @@ -0,0 +1,237 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py' +) +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 + +weight_decay = 0.05 +train_batch_size_per_gpu = 8 +load_from = 'pretrained_models/yolo_world_m_clip_base_dual_vlpan_2e-3adamw_32xb16_100e_o365_goldg_train_pretrained-2b7bd1be.pth' +persistent_workers = False + +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = False +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + frozen_stages=4, # frozen the image backbone + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name='openai/clip-vit-base-patch32', + frozen_modules=['all'])), + neck=dict(type='YOLOWorldDualPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv'), + text_enhancder=dict(type='ImagePoolingAttentionModule', + embed_channels=256, + num_heads=8)), + bbox_head=dict(type='YOLOWorldSegHead', + head_module=dict(type='YOLOWorldSegHeadModule', + embed_dims=text_channels, + num_classes=num_training_classes, + mask_channels=32, + proto_channels=256, + freeze_bbox=True), + mask_overlap=mask_overlap, + loss_mask=dict(type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none'), + loss_mask_weight=1.0), + train_cfg=dict(assigner=dict(num_classes=num_training_classes)), + test_cfg=dict(mask_thr_binary=0.5, fast_test=True)) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=True) +] + +last_transform = [ + dict(type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict(type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', + 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), +] + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=True) +] +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform, *text_transform +] + +_train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict(type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict(type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] +train_pipeline_stage2 = [*_train_pipeline_stage2, *text_transform] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco', + ann_file='lvis/lvis_v1_train_base.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32)), + class_text_path='data/texts/lvis_v1_base_class_texts.json', + pipeline=train_pipeline) +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + 'neck': + dict(lr_mult=0.0), + 'head.head_module.reg_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_contrasts': + dict(lr_mult=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/captions/lvis_v1_class_captions.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_v2_seg_l_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_v2_seg_l_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py new file mode 100644 index 0000000000000000000000000000000000000000..062c9e31ed02a1ab84a68f59ca1e5f86a389a2d6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_v2_seg_l_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py @@ -0,0 +1,239 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py' +) +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 + +weight_decay = 0.05 +train_batch_size_per_gpu = 8 +load_from = 'pretrained_models/yolo_world_l_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_cc3mlite_train-ca93cd1f.pth' +# text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = False +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + frozen_stages=4, # frozen the image backbone + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldSegHead', + head_module=dict(type='YOLOWorldSegHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes, + mask_channels=32, + proto_channels=256, + freeze_bbox=True), + mask_overlap=mask_overlap, + loss_mask=dict(type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none'), + loss_mask_weight=1.0), + train_cfg=dict(assigner=dict( + type='YOLOWorldSegAssigner', + num_classes=num_training_classes)), + test_cfg=dict(mask_thr_binary=0.5, fast_test=True)) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=True) +] + +last_transform = [ + dict(type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict(type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', + 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), +] + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=True) +] +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform, *text_transform +] + +_train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict(type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict(type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] +train_pipeline_stage2 = [*_train_pipeline_stage2, *text_transform] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco', + ann_file='lvis/lvis_v1_train_base.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32)), + class_text_path='data/texts/lvis_v1_base_class_texts.json', + pipeline=train_pipeline) +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + 'neck': + dict(lr_mult=0.0), + 'head.head_module.reg_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_contrasts': + dict(lr_mult=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_v2_seg_m_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_v2_seg_m_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py new file mode 100644 index 0000000000000000000000000000000000000000..d196d4ee1956d8c94bfcef1ad6da10f6b9af39b8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/configs/segmentation/yolo_world_v2_seg_m_vlpan_bn_2e-4_80e_8gpus_seghead_finetune_lvis.py @@ -0,0 +1,239 @@ +_base_ = ( + '../../third_party/mmyolo/configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py' +) +custom_imports = dict(imports=['yolo_world'], allow_failed_imports=False) +# hyper-parameters +num_classes = 1203 +num_training_classes = 80 +max_epochs = 80 # Maximum training epochs +close_mosaic_epochs = 10 +save_epoch_intervals = 5 +text_channels = 512 +neck_embed_channels = [128, 256, _base_.last_stage_out_channels // 2] +neck_num_heads = [4, 8, _base_.last_stage_out_channels // 2 // 32] +base_lr = 2e-4 + +weight_decay = 0.05 +train_batch_size_per_gpu = 8 +load_from = 'pretrained_models/yolo_world_m_clip_t2i_bn_2e-3adamw_32xb16-100e_obj365v1_goldg_train-c6237d5b.pth' +text_model_name = '../pretrained_models/clip-vit-base-patch32-projection' +# text_model_name = 'openai/clip-vit-base-patch32' +persistent_workers = False + +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = False +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 + +# model settings +model = dict( + type='YOLOWorldDetector', + mm_neck=True, + num_train_classes=num_training_classes, + num_test_classes=num_classes, + data_preprocessor=dict(type='YOLOWDetDataPreprocessor'), + backbone=dict( + _delete_=True, + type='MultiModalYOLOBackbone', + image_model={{_base_.model.backbone}}, + frozen_stages=4, # frozen the image backbone + text_model=dict( + type='HuggingCLIPLanguageBackbone', + model_name=text_model_name, + frozen_modules=['all'])), + neck=dict(type='YOLOWorldPAFPN', + freeze_all=True, + guide_channels=text_channels, + embed_channels=neck_embed_channels, + num_heads=neck_num_heads, + block_cfg=dict(type='MaxSigmoidCSPLayerWithTwoConv')), + bbox_head=dict(type='YOLOWorldSegHead', + head_module=dict(type='YOLOWorldSegHeadModule', + use_bn_head=True, + embed_dims=text_channels, + num_classes=num_training_classes, + mask_channels=32, + proto_channels=256, + freeze_bbox=True), + mask_overlap=mask_overlap, + loss_mask=dict(type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none'), + loss_mask_weight=1.0), + train_cfg=dict(assigner=dict( + type='YOLOWorldSegAssigner', + num_classes=num_training_classes)), + test_cfg=dict(mask_thr_binary=0.5, fast_test=True)) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=True) +] + +last_transform = [ + dict(type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict(type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', + 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), +] + +# dataset settings +text_transform = [ + dict(type='RandomLoadText', + num_neg_samples=(num_classes, num_classes), + max_num_samples=num_training_classes, + padding_to_max=True, + padding_value=''), + dict(type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction', 'texts')) +] +mosaic_affine_transform = [ + dict(type='MultiModalMosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=_base_.copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=True) +] +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict(type='YOLOv5MultiModalMixUp', + prob=_base_.mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform, *text_transform +] + +_train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict(type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict(type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, + 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] +train_pipeline_stage2 = [*_train_pipeline_stage2, *text_transform] +coco_train_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco', + ann_file='lvis/lvis_v1_train_base.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32)), + class_text_path='data/texts/lvis_v1_base_class_texts.json', + pipeline=train_pipeline) +train_dataloader = dict(persistent_workers=persistent_workers, + batch_size=train_batch_size_per_gpu, + collate_fn=dict(type='yolow_collate'), + dataset=coco_train_dataset) + +test_pipeline = [ + *_base_.test_pipeline[:-1], + dict(type='LoadText'), + dict(type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'texts')) +] + +# training settings +default_hooks = dict(param_scheduler=dict(scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict(max_keep_ckpts=-1, + save_best=None, + interval=save_epoch_intervals)) +custom_hooks = [ + dict(type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict(type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] +train_cfg = dict(max_epochs=max_epochs, + val_interval=5, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + _base_.val_interval_stage2)]) +optim_wrapper = dict(optimizer=dict( + _delete_=True, + type='AdamW', + lr=base_lr, + weight_decay=weight_decay, + batch_size_per_gpu=train_batch_size_per_gpu), + paramwise_cfg=dict(bias_decay_mult=0.0, + norm_decay_mult=0.0, + custom_keys={ + 'backbone.text_model': + dict(lr_mult=0.01), + 'logit_scale': + dict(weight_decay=0.0), + 'neck': + dict(lr_mult=0.0), + 'head.head_module.reg_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_preds': + dict(lr_mult=0.0), + 'head.head_module.cls_contrasts': + dict(lr_mult=0.0) + }), + constructor='YOLOWv5OptimizerConstructor') + +# evaluation settings +coco_val_dataset = dict( + _delete_=True, + type='MultiModalDataset', + dataset=dict(type='YOLOv5LVISV1Dataset', + data_root='data/coco/', + test_mode=True, + ann_file='lvis/lvis_v1_val.json', + data_prefix=dict(img=''), + batch_shapes_cfg=None), + class_text_path='data/texts/lvis_v1_class_texts.json', + pipeline=test_pipeline) +val_dataloader = dict(dataset=coco_val_dataset) +test_dataloader = val_dataloader + +val_evaluator = dict(type='mmdet.LVISMetric', + ann_file='data/coco/lvis/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/coco/lvis/lvis_v1_minival_inserted_image_name.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/coco/lvis/lvis_v1_minival_inserted_image_name.json new file mode 100644 index 0000000000000000000000000000000000000000..6bd2c04ec085318789058f787969998cafe4976d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/coco/lvis/lvis_v1_minival_inserted_image_name.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02301f6ccd89d1ee3d35112cb57d000c3396f34e4073066c90b2c1fbf47b55ce +size 35463626 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/coco_class_texts.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/coco_class_texts.json new file mode 100644 index 0000000000000000000000000000000000000000..b83ee71a04c5d2606793ea9e271a8422ca762ed5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/coco_class_texts.json @@ -0,0 +1 @@ +[["person"], ["bicycle"], ["car"], ["motorcycle"], ["airplane"], ["bus"], ["train"], ["truck"], ["boat"], ["traffic light"], ["fire hydrant"], ["stop sign"], ["parking meter"], ["bench"], ["bird"], ["cat"], ["dog"], ["horse"], ["sheep"], ["cow"], ["elephant"], ["bear"], ["zebra"], ["giraffe"], ["backpack"], ["umbrella"], ["handbag"], ["tie"], ["suitcase"], ["frisbee"], ["skis"], ["snowboard"], ["sports ball"], ["kite"], ["baseball bat"], ["baseball glove"], ["skateboard"], ["surfboard"], ["tennis racket"], ["bottle"], ["wine glass"], ["cup"], ["fork"], ["knife"], ["spoon"], ["bowl"], ["banana"], ["apple"], ["sandwich"], ["orange"], ["broccoli"], ["carrot"], ["hot dog"], ["pizza"], ["donut"], ["cake"], ["chair"], ["couch"], ["potted plant"], ["bed"], ["dining table"], ["toilet"], ["tv"], ["laptop"], ["mouse"], ["remote"], ["keyboard"], ["cell phone"], ["microwave"], ["oven"], ["toaster"], ["sink"], ["refrigerator"], ["book"], ["clock"], ["vase"], ["scissors"], ["teddy bear"], ["hair drier"], ["toothbrush"]] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/lvis_v1_base_class_captions.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/lvis_v1_base_class_captions.json new file mode 100644 index 0000000000000000000000000000000000000000..27e5e72636076fccdbbe7a93ffb56d2d8bbe0a3f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/lvis_v1_base_class_captions.json @@ -0,0 +1 @@ +[["aerosol can", "spray can"], ["air conditioner"], ["airplane", "aeroplane"], ["alarm clock"], ["alcohol", "alcoholic beverage"], ["alligator", "gator"], ["almond"], ["ambulance"], ["amplifier"], ["anklet", "ankle bracelet"], ["antenna", "aerial", "transmitting aerial"], ["apple"], ["apron"], ["aquarium", "fish tank"], ["armband"], ["armchair"], ["artichoke"], ["trash can", "garbage can", "wastebin", "dustbin", "trash barrel", "trash bin"], ["ashtray"], ["asparagus"], ["atomizer", "atomiser", "spray", "sprayer", "nebulizer", "nebuliser"], ["avocado"], ["award", "accolade"], ["awning"], ["baby buggy", "baby carriage", "perambulator", "pram", "stroller"], ["basketball backboard"], ["backpack", "knapsack", "packsack", "rucksack", "haversack"], ["handbag", "purse", "pocketbook"], ["suitcase", "baggage", "luggage"], ["bagel", "beigel"], ["ball"], ["balloon"], ["bamboo"], ["banana"], ["Band Aid"], ["bandage"], ["bandanna", "bandana"], ["banner", "streamer"], ["barrel", "cask"], ["barrette"], ["barrow", "garden cart", "lawn cart", "wheelbarrow"], ["baseball base"], ["baseball"], ["baseball bat"], ["baseball cap", "jockey cap", "golf cap"], ["baseball glove", "baseball mitt"], ["basket", "handbasket"], ["basketball"], ["bat", "bat animal"], ["bath mat"], ["bath towel"], ["bathrobe"], ["bathtub", "bathing tub"], ["battery"], ["bead"], ["bean curd", "tofu"], ["beanbag"], ["beanie", "beany"], ["bear"], ["bed"], ["bedspread", "bedcover", "bed covering", "counterpane", "spread"], ["cow"], ["beef", "beef food", "boeuf", "boeuf food"], ["beer bottle"], ["beer can"], ["bell"], ["bell pepper", "capsicum"], ["belt"], ["belt buckle"], ["bench"], ["beret"], ["bib"], ["bicycle", "bike", "bike bicycle"], ["visor", "vizor"], ["billboard"], ["binder", "ring-binder"], ["binoculars", "field glasses", "opera glasses"], ["bird"], ["birdfeeder"], ["birdbath"], ["birdcage"], ["birdhouse"], ["birthday cake"], ["black sheep"], ["blackberry"], ["blackboard", "chalkboard"], ["blanket"], ["blazer", "sport jacket", "sport coat", "sports jacket", "sports coat"], ["blender", "liquidizer", "liquidiser"], ["blinker", "flasher"], ["blouse"], ["blueberry"], ["boat", "ship", "ship boat"], ["bobbin", "spool", "reel"], ["bobby pin", "hairgrip"], ["boiled egg", "coddled egg"], ["deadbolt"], ["bolt"], ["book"], ["bookcase"], ["booklet", "brochure", "leaflet", "pamphlet"], ["boot"], ["bottle"], ["bottle opener"], ["bouquet"], ["bow", "bow decorative ribbons"], ["bow-tie", "bowtie"], ["bowl"], ["bowler hat", "bowler", "derby hat", "derby", "plug hat"], ["box"], ["suspenders"], ["bracelet", "bangle"], ["brassiere", "bra", "bandeau"], ["bread-bin", "breadbox"], ["bread"], ["bridal gown", "wedding gown", "wedding dress"], ["briefcase"], ["broccoli"], ["broom"], ["brownie"], ["brussels sprouts"], ["bucket", "pail"], ["horned cow"], ["bulldog"], ["bullet train"], ["bulletin board", "notice board"], ["bullhorn", "megaphone"], ["bun", "roll"], ["bunk bed"], ["buoy"], ["bus", "bus vehicle", "autobus", "charabanc", "double-decker", "motorbus", "motorcoach"], ["business card"], ["butter"], ["butterfly"], ["button"], ["cab", "cab taxi", "taxi", "taxicab"], ["cabin car", "caboose"], ["cabinet"], ["cake"], ["calculator"], ["calendar"], ["calf"], ["camcorder"], ["camel"], ["camera"], ["camera lens"], ["camper", "camper vehicle", "camping bus", "motor home"], ["can", "tin can"], ["can opener", "tin opener"], ["candle", "candlestick"], ["candle holder"], ["candy cane"], ["walking cane"], ["canister", "cannister"], ["canoe"], ["cantaloup", "cantaloupe"], ["cap", "cap headwear"], ["bottle cap", "cap", "cap container lid"], ["cape"], ["cappuccino", "coffee cappuccino"], ["car", "car automobile", "auto", "auto automobile", "automobile"], ["railcar", "railcar part of a train", "railway car", "railway car part of a train", "railroad car", "railroad car part of a train"], ["identity card"], ["card"], ["cardigan"], ["horse carriage"], ["carrot"], ["tote bag"], ["cart"], ["carton"], ["cash register", "register", "register for cash transactions"], ["cast", "plaster cast", "plaster bandage"], ["cat"], ["cauliflower"], ["cayenne", "cayenne spice", "cayenne pepper", "cayenne pepper spice", "red pepper", "red pepper spice"], ["CD player"], ["celery"], ["cellular telephone", "cellular phone", "cellphone", "mobile phone", "smart phone"], ["chair"], ["chandelier"], ["cherry"], ["chicken", "chicken animal"], ["chickpea", "garbanzo"], ["chili", "chili vegetable", "chili pepper", "chili pepper vegetable", "chilli", "chilli vegetable", "chilly", "chilly vegetable", "chile", "chile vegetable"], ["crisp", "crisp potato chip", "potato chip"], ["chocolate bar"], ["chocolate cake"], ["choker", "collar", "neckband"], ["chopping board", "cutting board", "chopping block"], ["chopstick"], ["Christmas tree"], ["slide"], ["cigarette"], ["cigarette case", "cigarette pack"], ["cistern", "water tank"], ["clasp"], ["cleansing agent", "cleanser", "cleaner"], ["clip"], ["clipboard"], ["clock", "timepiece", "timekeeper"], ["clock tower"], ["clothes hamper", "laundry basket", "clothes basket"], ["clothespin", "clothes peg"], ["coaster"], ["coat"], ["coat hanger", "clothes hanger", "dress hanger"], ["coatrack", "hatrack"], ["cock", "rooster"], ["coconut", "cocoanut"], ["coffee maker", "coffee machine"], ["coffee table", "cocktail table"], ["coffeepot"], ["coin"], ["colander", "cullender"], ["coleslaw", "slaw"], ["pacifier", "teething ring"], ["computer keyboard", "keyboard", "keyboard computer"], ["condiment"], ["cone", "traffic cone"], ["control", "controller"], ["cookie", "cooky", "biscuit", "biscuit cookie"], ["cooler", "cooler for food", "ice chest"], ["cork", "cork bottle plug", "bottle cork"], ["corkscrew", "bottle screw"], ["edible corn", "corn", "maize"], ["cornet", "horn", "trumpet"], ["cornice", "valance", "valance board", "pelmet"], ["corset", "girdle"], ["costume"], ["cowbell"], ["cowboy hat", "ten-gallon hat"], ["crab", "crab animal"], ["cracker"], ["crate"], ["crayon", "wax crayon"], ["crescent roll", "croissant"], ["crib", "cot"], ["crock pot", "earthenware jar"], ["crossbar"], ["crow"], ["crown"], ["crucifix"], ["cruise ship", "cruise liner"], ["police cruiser", "patrol car", "police car", "squad car"], ["crumb"], ["crutch"], ["cub", "cub animal"], ["cube", "square block"], ["cucumber", "cuke"], ["cufflink"], ["cup"], ["trophy cup"], ["cupboard", "closet"], ["cupcake"], ["curtain", "drapery"], ["cushion"], ["dartboard"], ["deck chair", "beach chair"], ["deer", "cervid"], ["dental floss", "floss"], ["desk"], ["diaper"], ["dining table"], ["dish"], ["dish antenna"], ["dishrag", "dishcloth"], ["dishtowel", "tea towel"], ["dishwasher", "dishwashing machine"], ["dispenser"], ["Dixie cup", "paper cup"], ["dog"], ["dog collar"], ["doll"], ["dolphin"], ["domestic ass", "donkey"], ["doorknob", "doorhandle"], ["doormat", "welcome mat"], ["doughnut", "donut"], ["drawer"], ["underdrawers", "boxers", "boxershorts"], ["dress", "frock"], ["dress hat", "high hat", "opera hat", "silk hat", "top hat"], ["dress suit"], ["dresser"], ["drill"], ["drum", "drum musical instrument"], ["duck"], ["duckling"], ["duct tape"], ["duffel bag", "duffle bag", "duffel", "duffle"], ["dumpster"], ["eagle"], ["earphone", "earpiece", "headphone"], ["earring"], ["easel"], ["egg", "eggs"], ["egg yolk", "yolk", "yolk egg"], ["eggbeater", "eggwhisk"], ["eggplant", "aubergine"], ["refrigerator"], ["elephant"], ["elk", "moose"], ["envelope"], ["eraser"], ["fan"], ["faucet", "spigot", "tap"], ["Ferris wheel"], ["ferry", "ferryboat"], ["fighter jet", "fighter aircraft", "attack aircraft"], ["figurine"], ["file cabinet", "filing cabinet"], ["fire alarm", "smoke alarm"], ["fire engine", "fire truck"], ["fire extinguisher", "extinguisher"], ["fire hose"], ["fireplace"], ["fireplug", "fire hydrant", "hydrant"], ["fish"], ["fish", "fish food"], ["fishing rod", "fishing pole"], ["flag"], ["flagpole", "flagstaff"], ["flamingo"], ["flannel"], ["flap"], ["flashlight", "torch"], ["flip-flop", "flip-flop sandal"], ["flipper", "flipper footwear", "fin", "fin footwear"], ["flower arrangement", "floral arrangement"], ["flute glass", "champagne flute"], ["foal"], ["folding chair"], ["food processor"], ["football", "football American"], ["footstool", "footrest"], ["fork"], ["forklift"], ["freight car"], ["French toast"], ["freshener", "air freshener"], ["frisbee"], ["frog", "toad", "toad frog"], ["fruit juice"], ["frying pan", "frypan", "skillet"], ["garbage truck"], ["garden hose"], ["gargle", "mouthwash"], ["garlic", "ail"], ["gazelle"], ["gelatin", "jelly"], ["giant panda", "panda", "panda bear"], ["gift wrap"], ["ginger", "gingerroot"], ["giraffe"], ["cincture", "sash", "waistband", "waistcloth"], ["glass", "glass drink container", "drinking glass"], ["globe"], ["glove"], ["goat"], ["goggles"], ["golf club", "golf-club"], ["golfcart"], ["goose"], ["grape"], ["grater"], ["gravestone", "headstone", "tombstone"], ["green bean"], ["green onion", "spring onion", "scallion"], ["grill", "grille", "grillwork", "radiator grille"], ["grizzly", "grizzly bear"], ["grocery bag"], ["guitar"], ["gull", "seagull"], ["gun"], ["hairbrush"], ["hairnet"], ["hairpin"], ["ham", "jambon", "gammon"], ["hamburger", "beefburger", "burger"], ["hammer"], ["hammock"], ["hamster"], ["hair dryer"], ["hand towel", "face towel"], ["handcart", "pushcart", "hand truck"], ["handkerchief"], ["handle", "grip", "handgrip"], ["hat"], ["veil"], ["headband"], ["headboard"], ["headlight", "headlamp"], ["headscarf"], ["headstall", "headstall for horses", "headpiece", "headpiece for horses"], ["heart"], ["heater", "warmer"], ["helicopter"], ["helmet"], ["highchair", "feeding chair"], ["hinge"], ["hog", "pig"], ["home plate", "home plate baseball", "home base", "home base baseball"], ["honey"], ["fume hood", "exhaust hood"], ["hook"], ["horse"], ["hose", "hosepipe"], ["hot sauce"], ["hummingbird"], ["polar bear"], ["icecream"], ["ice maker"], ["igniter", "ignitor", "lighter"], ["iPod"], ["iron", "iron for clothing", "smoothing iron", "smoothing iron for clothing"], ["ironing board"], ["jacket"], ["jam"], ["jar"], ["jean", "blue jean", "denim"], ["jeep", "landrover"], ["jersey", "T-shirt", "tee shirt"], ["jet plane", "jet-propelled plane"], ["jewelry", "jewellery"], ["jumpsuit"], ["kayak"], ["kettle", "boiler"], ["key"], ["kilt"], ["kimono"], ["kitchen sink"], ["kite"], ["kitten", "kitty"], ["kiwi fruit"], ["knee pad"], ["knife"], ["knob"], ["ladder"], ["ladle"], ["ladybug", "ladybeetle", "ladybird beetle"], ["lamb", "lamb animal"], ["lamp"], ["lamppost"], ["lampshade"], ["lantern"], ["lanyard", "laniard"], ["laptop computer", "notebook computer"], ["latch"], ["legging", "legging clothing", "leging", "leging clothing", "leg covering"], ["Lego", "Lego set"], ["lemon"], ["lettuce"], ["license plate", "numberplate"], ["life buoy", "lifesaver", "life belt", "life ring"], ["life jacket", "life vest"], ["lightbulb"], ["lime"], ["lion"], ["lip balm"], ["lizard"], ["log"], ["lollipop"], ["speaker", "speaker stereo equipment"], ["loveseat"], ["magazine"], ["magnet"], ["mail slot"], ["mailbox", "mailbox at home", "letter box", "letter box at home"], ["mandarin orange"], ["manger", "trough"], ["manhole"], ["map"], ["marker"], ["mashed potato"], ["mask", "facemask"], ["mast"], ["mat", "mat gym equipment", "gym mat"], ["mattress"], ["measuring cup"], ["measuring stick", "ruler", "ruler measuring stick", "measuring rod"], ["meatball"], ["medicine"], ["melon"], ["microphone"], ["microwave oven"], ["milk"], ["minivan"], ["mirror"], ["mitten"], ["mixer", "mixer kitchen tool", "stand mixer"], ["money"], ["monitor", "monitor computer equipment"], ["monkey"], ["motor"], ["motor scooter", "scooter"], ["motorcycle"], ["mound", "mound baseball", "pitcher's mound"], ["mouse", "mouse computer equipment", "computer mouse"], ["mousepad"], ["muffin"], ["mug"], ["mushroom"], ["musical instrument", "instrument", "instrument musical"], ["napkin", "table napkin", "serviette"], ["necklace"], ["necktie", "tie", "tie necktie"], ["needle"], ["nest"], ["newspaper", "paper", "paper newspaper"], ["newsstand"], ["nightshirt", "nightwear", "sleepwear", "nightclothes"], ["noseband", "noseband for animals", "nosepiece", "nosepiece for animals"], ["notebook"], ["notepad"], ["nut"], ["oar"], ["oil lamp", "kerosene lamp", "kerosine lamp"], ["olive oil"], ["onion"], ["orange", "orange fruit"], ["orange juice"], ["ostrich"], ["ottoman", "pouf", "pouffe", "hassock"], ["oven"], ["overalls", "overalls clothing"], ["owl"], ["packet"], ["pad"], ["paddle", "boat paddle"], ["padlock"], ["paintbrush"], ["painting"], ["pajamas", "pyjamas"], ["palette", "pallet"], ["pan", "pan for cooking", "cooking pan"], ["pancake"], ["paper plate"], ["paper towel"], ["parachute"], ["parakeet", "parrakeet", "parroket", "paraquet", "paroquet", "parroquet"], ["parasail", "parasail sports"], ["parasol", "sunshade"], ["parka", "anorak"], ["parking meter"], ["parrot"], ["passenger car", "passenger car part of a train", "coach", "coach part of a train"], ["passport"], ["pastry"], ["pea", "pea food"], ["peach"], ["peanut butter"], ["pear"], ["peeler", "peeler tool for fruit and vegetables"], ["pelican"], ["pen"], ["pencil"], ["penguin"], ["pepper", "peppercorn"], ["pepper mill", "pepper grinder"], ["perfume"], ["person", "baby", "child", "boy", "girl", "man", "woman", "human"], ["pet"], ["pew", "pew church bench", "church bench"], ["phonograph record", "phonograph recording", "record", "record phonograph recording"], ["piano"], ["pickle"], ["pickup truck"], ["pie"], ["pigeon"], ["pillow"], ["pineapple"], ["pinecone"], ["pipe", "piping"], ["pita", "pita bread", "pocket bread"], ["pitcher", "pitcher vessel for liquid", "ewer"], ["pizza"], ["place mat"], ["plate"], ["platter"], ["pliers", "plyers"], ["pocketknife"], ["poker", "poker fire stirring tool", "stove poker", "fire hook"], ["pole", "post"], ["polo shirt", "sport shirt"], ["pony"], ["pop", "pop soda", "soda", "soda pop", "tonic", "soft drink"], ["postbox", "postbox public", "mailbox", "mailbox public"], ["postcard", "postal card", "mailing-card"], ["poster", "placard"], ["pot"], ["flowerpot"], ["potato"], ["potholder"], ["pottery", "clayware"], ["pouch"], ["power shovel", "excavator", "digger"], ["prawn", "shrimp"], ["pretzel"], ["printer", "printing machine"], ["projectile", "projectile weapon", "missile"], ["projector"], ["propeller", "propellor"], ["pumpkin"], ["puppy"], ["quilt", "comforter"], ["rabbit"], ["racket", "racquet"], ["radiator"], ["radio receiver", "radio set", "radio", "tuner", "tuner radio"], ["radish", "daikon"], ["raft"], ["raincoat", "waterproof jacket"], ["ram", "ram animal"], ["raspberry"], ["razorblade"], ["reamer", "reamer juicer", "juicer", "juice reamer"], ["rearview mirror"], ["receipt"], ["recliner", "reclining chair", "lounger", "lounger chair"], ["record player", "phonograph", "phonograph record player", "turntable"], ["reflector"], ["remote control"], ["rhinoceros"], ["rifle"], ["ring"], ["robe"], ["rocking chair"], ["rolling pin"], ["router", "router computer equipment"], ["rubber band", "elastic band"], ["runner", "runner carpet"], ["plastic bag", "paper bag"], ["saddle", "saddle on an animal"], ["saddle blanket", "saddlecloth", "horse blanket"], ["saddlebag"], ["sail"], ["salad"], ["salami"], ["salmon", "salmon fish"], ["salsa"], ["saltshaker"], ["sandal", "sandal type of shoe"], ["sandwich"], ["saucer"], ["sausage"], ["scale", "scale measuring instrument"], ["scarf"], ["school bus"], ["scissors"], ["scoreboard"], ["screwdriver"], ["scrubbing brush"], ["sculpture"], ["seabird", "seafowl"], ["seahorse"], ["seashell"], ["sewing machine"], ["shaker"], ["shampoo"], ["shark"], ["shaving cream", "shaving soap"], ["sheep"], ["shield"], ["shirt"], ["shoe", "sneaker", "sneaker type of shoe", "tennis shoe"], ["shopping bag"], ["shopping cart"], ["short pants", "shorts", "shorts clothing", "trunks", "trunks clothing"], ["shoulder bag"], ["shovel"], ["shower head"], ["shower curtain"], ["signboard"], ["silo"], ["sink"], ["skateboard"], ["skewer"], ["ski"], ["ski boot"], ["ski parka", "ski jacket"], ["ski pole"], ["skirt"], ["sled", "sledge", "sleigh"], ["sleeping bag"], ["slipper", "slipper footwear", "carpet slipper", "carpet slipper footwear"], ["snowboard"], ["snowman"], ["snowmobile"], ["soap"], ["soccer ball"], ["sock"], ["sofa", "couch", "lounge"], ["solar array", "solar battery", "solar panel"], ["soup"], ["soupspoon"], ["sour cream", "soured cream"], ["spatula"], ["spectacles", "specs", "eyeglasses", "glasses"], ["spice rack"], ["spider"], ["sponge"], ["spoon"], ["sportswear", "athletic wear", "activewear"], ["spotlight"], ["squirrel"], ["stapler", "stapler stapling machine"], ["starfish", "sea star"], ["statue", "statue sculpture"], ["steak", "steak food"], ["steering wheel"], ["step stool"], ["stereo", "stereo sound system"], ["stirrup"], ["stool"], ["stop sign"], ["brake light"], ["stove", "kitchen stove", "range", "range kitchen appliance", "kitchen range", "cooking stove"], ["strainer"], ["strap"], ["straw", "straw for drinking", "drinking straw"], ["strawberry"], ["street sign"], ["streetlight", "street lamp"], ["suit", "suit clothing"], ["sunflower"], ["sunglasses"], ["sunhat"], ["surfboard"], ["sushi"], ["mop"], ["sweat pants"], ["sweatband"], ["sweater"], ["sweatshirt"], ["sweet potato"], ["swimsuit", "swimwear", "bathing suit", "swimming costume", "bathing costume", "swimming trunks", "bathing trunks"], ["sword"], ["table"], ["table lamp"], ["tablecloth"], ["tag"], ["taillight", "rear light"], ["tank", "tank storage vessel", "storage tank"], ["tank top", "tank top clothing"], ["tape", "tape sticky cloth or paper"], ["tape measure", "measuring tape"], ["tapestry"], ["tarp"], ["tartan", "plaid"], ["tassel"], ["tea bag"], ["teacup"], ["teakettle"], ["teapot"], ["teddy bear"], ["telephone", "phone", "telephone set"], ["telephone booth", "phone booth", "call box", "telephone box", "telephone kiosk"], ["telephone pole", "telegraph pole", "telegraph post"], ["television camera", "tv camera"], ["television set", "tv", "tv set"], ["tennis ball"], ["tennis racket"], ["thermometer"], ["thermos bottle"], ["thermostat"], ["thread", "yarn"], ["thumbtack", "drawing pin", "pushpin"], ["tiara"], ["tiger"], ["tights", "tights clothing", "leotards"], ["timer", "stopwatch"], ["tinfoil"], ["tinsel"], ["tissue paper"], ["toast", "toast food"], ["toaster"], ["toaster oven"], ["toilet"], ["toilet tissue", "toilet paper", "bathroom tissue"], ["tomato"], ["tongs"], ["toolbox"], ["toothbrush"], ["toothpaste"], ["toothpick"], ["cover"], ["tortilla"], ["tow truck"], ["towel"], ["towel rack", "towel rail", "towel bar"], ["toy"], ["tractor", "tractor farm equipment"], ["traffic light"], ["dirt bike"], ["trailer truck", "tractor trailer", "trucking rig", "articulated lorry", "semi truck"], ["train", "train railroad vehicle", "railroad train"], ["tray"], ["tricycle"], ["tripod"], ["trousers", "pants", "pants clothing"], ["truck"], ["trunk"], ["turban"], ["turkey", "turkey food"], ["turtle"], ["turtleneck", "turtleneck clothing", "polo-neck"], ["typewriter"], ["umbrella"], ["underwear", "underclothes", "underclothing", "underpants"], ["urinal"], ["urn"], ["vacuum cleaner"], ["vase"], ["vending machine"], ["vent", "blowhole", "air vent"], ["vest", "waistcoat"], ["videotape"], ["volleyball"], ["waffle"], ["wagon"], ["wagon wheel"], ["walking stick"], ["wall clock"], ["wall socket", "wall plug", "electric outlet", "electrical outlet", "outlet", "electric receptacle"], ["wallet", "billfold"], ["automatic washer", "washing machine"], ["watch", "wristwatch"], ["water bottle"], ["water cooler"], ["water faucet", "water tap", "tap", "tap water faucet"], ["water jug"], ["water scooter", "sea scooter", "jet ski"], ["water ski"], ["water tower"], ["watering can"], ["watermelon"], ["weathervane", "vane", "vane weathervane", "wind vane"], ["webcam"], ["wedding cake", "bridecake"], ["wedding ring", "wedding band"], ["wet suit"], ["wheel"], ["wheelchair"], ["whipped cream"], ["whistle"], ["wig"], ["wind chime"], ["windmill"], ["window box", "window box for plants"], ["windshield wiper", "windscreen wiper", "wiper", "wiper for windshield or screen"], ["windsock", "air sock", "air-sleeve", "wind sleeve", "wind cone"], ["wine bottle"], ["wine bucket", "wine cooler"], ["wineglass"], ["blinder", "blinder for horses"], ["wok"], ["wooden spoon"], ["wreath"], ["wrench", "spanner"], ["wristband"], ["wristlet", "wrist band"], ["yacht"], ["yogurt", "yoghurt", "yoghourt"], ["yoke", "yoke animal equipment"], ["zebra"], ["zucchini", "courgette"]] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/lvis_v1_class_texts.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/lvis_v1_class_texts.json new file mode 100644 index 0000000000000000000000000000000000000000..367aaf5430da14c914503b46e4a91bd1542849dd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/lvis_v1_class_texts.json @@ -0,0 +1 @@ +[["aerosol can", "spray can"], ["air conditioner"], ["airplane", "aeroplane"], ["alarm clock"], ["alcohol", "alcoholic beverage"], ["alligator", "gator"], ["almond"], ["ambulance"], ["amplifier"], ["anklet", "ankle bracelet"], ["antenna", "aerial", "transmitting aerial"], ["apple"], ["applesauce"], ["apricot"], ["apron"], ["aquarium", "fish tank"], ["arctic", "arctic type of shoe", "galosh", "golosh", "rubber", "rubber type of shoe", "gumshoe"], ["armband"], ["armchair"], ["armoire"], ["armor", "armour"], ["artichoke"], ["trash can", "garbage can", "wastebin", "dustbin", "trash barrel", "trash bin"], ["ashtray"], ["asparagus"], ["atomizer", "atomiser", "spray", "sprayer", "nebulizer", "nebuliser"], ["avocado"], ["award", "accolade"], ["awning"], ["ax", "axe"], ["baboon"], ["baby buggy", "baby carriage", "perambulator", "pram", "stroller"], ["basketball backboard"], ["backpack", "knapsack", "packsack", "rucksack", "haversack"], ["handbag", "purse", "pocketbook"], ["suitcase", "baggage", "luggage"], ["bagel", "beigel"], ["bagpipe"], ["baguet", "baguette"], ["bait", "lure"], ["ball"], ["ballet skirt", "tutu"], ["balloon"], ["bamboo"], ["banana"], ["Band Aid"], ["bandage"], ["bandanna", "bandana"], ["banjo"], ["banner", "streamer"], ["barbell"], ["barge"], ["barrel", "cask"], ["barrette"], ["barrow", "garden cart", "lawn cart", "wheelbarrow"], ["baseball base"], ["baseball"], ["baseball bat"], ["baseball cap", "jockey cap", "golf cap"], ["baseball glove", "baseball mitt"], ["basket", "handbasket"], ["basketball"], ["bass horn", "sousaphone", "tuba"], ["bat", "bat animal"], ["bath mat"], ["bath towel"], ["bathrobe"], ["bathtub", "bathing tub"], ["batter", "batter food"], ["battery"], ["beachball"], ["bead"], ["bean curd", "tofu"], ["beanbag"], ["beanie", "beany"], ["bear"], ["bed"], ["bedpan"], ["bedspread", "bedcover", "bed covering", "counterpane", "spread"], ["cow"], ["beef", "beef food", "boeuf", "boeuf food"], ["beeper", "pager"], ["beer bottle"], ["beer can"], ["beetle"], ["bell"], ["bell pepper", "capsicum"], ["belt"], ["belt buckle"], ["bench"], ["beret"], ["bib"], ["Bible"], ["bicycle", "bike", "bike bicycle"], ["visor", "vizor"], ["billboard"], ["binder", "ring-binder"], ["binoculars", "field glasses", "opera glasses"], ["bird"], ["birdfeeder"], ["birdbath"], ["birdcage"], ["birdhouse"], ["birthday cake"], ["birthday card"], ["pirate flag"], ["black sheep"], ["blackberry"], ["blackboard", "chalkboard"], ["blanket"], ["blazer", "sport jacket", "sport coat", "sports jacket", "sports coat"], ["blender", "liquidizer", "liquidiser"], ["blimp"], ["blinker", "flasher"], ["blouse"], ["blueberry"], ["gameboard"], ["boat", "ship", "ship boat"], ["bob", "bobber", "bobfloat"], ["bobbin", "spool", "reel"], ["bobby pin", "hairgrip"], ["boiled egg", "coddled egg"], ["bolo tie", "bolo", "bola tie", "bola"], ["deadbolt"], ["bolt"], ["bonnet"], ["book"], ["bookcase"], ["booklet", "brochure", "leaflet", "pamphlet"], ["bookmark", "bookmarker"], ["boom microphone", "microphone boom"], ["boot"], ["bottle"], ["bottle opener"], ["bouquet"], ["bow", "bow weapon"], ["bow", "bow decorative ribbons"], ["bow-tie", "bowtie"], ["bowl"], ["pipe bowl"], ["bowler hat", "bowler", "derby hat", "derby", "plug hat"], ["bowling ball"], ["box"], ["boxing glove"], ["suspenders"], ["bracelet", "bangle"], ["brass plaque"], ["brassiere", "bra", "bandeau"], ["bread-bin", "breadbox"], ["bread"], ["breechcloth", "breechclout", "loincloth"], ["bridal gown", "wedding gown", "wedding dress"], ["briefcase"], ["broccoli"], ["broach"], ["broom"], ["brownie"], ["brussels sprouts"], ["bubble gum"], ["bucket", "pail"], ["horse buggy"], ["horned cow"], ["bulldog"], ["bulldozer", "dozer"], ["bullet train"], ["bulletin board", "notice board"], ["bulletproof vest"], ["bullhorn", "megaphone"], ["bun", "roll"], ["bunk bed"], ["buoy"], ["burrito"], ["bus", "bus vehicle", "autobus", "charabanc", "double-decker", "motorbus", "motorcoach"], ["business card"], ["butter"], ["butterfly"], ["button"], ["cab", "cab taxi", "taxi", "taxicab"], ["cabana"], ["cabin car", "caboose"], ["cabinet"], ["locker", "storage locker"], ["cake"], ["calculator"], ["calendar"], ["calf"], ["camcorder"], ["camel"], ["camera"], ["camera lens"], ["camper", "camper vehicle", "camping bus", "motor home"], ["can", "tin can"], ["can opener", "tin opener"], ["candle", "candlestick"], ["candle holder"], ["candy bar"], ["candy cane"], ["walking cane"], ["canister", "cannister"], ["canoe"], ["cantaloup", "cantaloupe"], ["canteen"], ["cap", "cap headwear"], ["bottle cap", "cap", "cap container lid"], ["cape"], ["cappuccino", "coffee cappuccino"], ["car", "car automobile", "auto", "auto automobile", "automobile"], ["railcar", "railcar part of a train", "railway car", "railway car part of a train", "railroad car", "railroad car part of a train"], ["elevator car"], ["car battery", "automobile battery"], ["identity card"], ["card"], ["cardigan"], ["cargo ship", "cargo vessel"], ["carnation"], ["horse carriage"], ["carrot"], ["tote bag"], ["cart"], ["carton"], ["cash register", "register", "register for cash transactions"], ["casserole"], ["cassette"], ["cast", "plaster cast", "plaster bandage"], ["cat"], ["cauliflower"], ["cayenne", "cayenne spice", "cayenne pepper", "cayenne pepper spice", "red pepper", "red pepper spice"], ["CD player"], ["celery"], ["cellular telephone", "cellular phone", "cellphone", "mobile phone", "smart phone"], ["chain mail", "ring mail", "chain armor", "chain armour", "ring armor", "ring armour"], ["chair"], ["chaise longue", "chaise", "daybed"], ["chalice"], ["chandelier"], ["chap"], ["checkbook", "chequebook"], ["checkerboard"], ["cherry"], ["chessboard"], ["chicken", "chicken animal"], ["chickpea", "garbanzo"], ["chili", "chili vegetable", "chili pepper", "chili pepper vegetable", "chilli", "chilli vegetable", "chilly", "chilly vegetable", "chile", "chile vegetable"], ["chime", "gong"], ["chinaware"], ["crisp", "crisp potato chip", "potato chip"], ["poker chip"], ["chocolate bar"], ["chocolate cake"], ["chocolate milk"], ["chocolate mousse"], ["choker", "collar", "neckband"], ["chopping board", "cutting board", "chopping block"], ["chopstick"], ["Christmas tree"], ["slide"], ["cider", "cyder"], ["cigar box"], ["cigarette"], ["cigarette case", "cigarette pack"], ["cistern", "water tank"], ["clarinet"], ["clasp"], ["cleansing agent", "cleanser", "cleaner"], ["cleat", "cleat for securing rope"], ["clementine"], ["clip"], ["clipboard"], ["clippers", "clippers for plants"], ["cloak"], ["clock", "timepiece", "timekeeper"], ["clock tower"], ["clothes hamper", "laundry basket", "clothes basket"], ["clothespin", "clothes peg"], ["clutch bag"], ["coaster"], ["coat"], ["coat hanger", "clothes hanger", "dress hanger"], ["coatrack", "hatrack"], ["cock", "rooster"], ["cockroach"], ["cocoa", "cocoa beverage", "hot chocolate", "hot chocolate beverage", "drinking chocolate"], ["coconut", "cocoanut"], ["coffee maker", "coffee machine"], ["coffee table", "cocktail table"], ["coffeepot"], ["coil"], ["coin"], ["colander", "cullender"], ["coleslaw", "slaw"], ["coloring material", "colouring material"], ["combination lock"], ["pacifier", "teething ring"], ["comic book"], ["compass"], ["computer keyboard", "keyboard", "keyboard computer"], ["condiment"], ["cone", "traffic cone"], ["control", "controller"], ["convertible", "convertible automobile"], ["sofa bed"], ["cooker"], ["cookie", "cooky", "biscuit", "biscuit cookie"], ["cooking utensil"], ["cooler", "cooler for food", "ice chest"], ["cork", "cork bottle plug", "bottle cork"], ["corkboard"], ["corkscrew", "bottle screw"], ["edible corn", "corn", "maize"], ["cornbread"], ["cornet", "horn", "trumpet"], ["cornice", "valance", "valance board", "pelmet"], ["cornmeal"], ["corset", "girdle"], ["costume"], ["cougar", "puma", "catamount", "mountain lion", "panther"], ["coverall"], ["cowbell"], ["cowboy hat", "ten-gallon hat"], ["crab", "crab animal"], ["crabmeat"], ["cracker"], ["crape", "crepe", "French pancake"], ["crate"], ["crayon", "wax crayon"], ["cream pitcher"], ["crescent roll", "croissant"], ["crib", "cot"], ["crock pot", "earthenware jar"], ["crossbar"], ["crouton"], ["crow"], ["crowbar", "wrecking bar", "pry bar"], ["crown"], ["crucifix"], ["cruise ship", "cruise liner"], ["police cruiser", "patrol car", "police car", "squad car"], ["crumb"], ["crutch"], ["cub", "cub animal"], ["cube", "square block"], ["cucumber", "cuke"], ["cufflink"], ["cup"], ["trophy cup"], ["cupboard", "closet"], ["cupcake"], ["hair curler", "hair roller", "hair crimper"], ["curling iron"], ["curtain", "drapery"], ["cushion"], ["cylinder"], ["cymbal"], ["dagger"], ["dalmatian"], ["dartboard"], ["date", "date fruit"], ["deck chair", "beach chair"], ["deer", "cervid"], ["dental floss", "floss"], ["desk"], ["detergent"], ["diaper"], ["diary", "journal"], ["die", "dice"], ["dinghy", "dory", "rowboat"], ["dining table"], ["tux", "tuxedo"], ["dish"], ["dish antenna"], ["dishrag", "dishcloth"], ["dishtowel", "tea towel"], ["dishwasher", "dishwashing machine"], ["dishwasher detergent", "dishwashing detergent", "dishwashing liquid", "dishsoap"], ["dispenser"], ["diving board"], ["Dixie cup", "paper cup"], ["dog"], ["dog collar"], ["doll"], ["dollar", "dollar bill", "one dollar bill"], ["dollhouse", "doll's house"], ["dolphin"], ["domestic ass", "donkey"], ["doorknob", "doorhandle"], ["doormat", "welcome mat"], ["doughnut", "donut"], ["dove"], ["dragonfly"], ["drawer"], ["underdrawers", "boxers", "boxershorts"], ["dress", "frock"], ["dress hat", "high hat", "opera hat", "silk hat", "top hat"], ["dress suit"], ["dresser"], ["drill"], ["drone"], ["dropper", "eye dropper"], ["drum", "drum musical instrument"], ["drumstick"], ["duck"], ["duckling"], ["duct tape"], ["duffel bag", "duffle bag", "duffel", "duffle"], ["dumbbell"], ["dumpster"], ["dustpan"], ["eagle"], ["earphone", "earpiece", "headphone"], ["earplug"], ["earring"], ["easel"], ["eclair"], ["eel"], ["egg", "eggs"], ["egg roll", "spring roll"], ["egg yolk", "yolk", "yolk egg"], ["eggbeater", "eggwhisk"], ["eggplant", "aubergine"], ["electric chair"], ["refrigerator"], ["elephant"], ["elk", "moose"], ["envelope"], ["eraser"], ["escargot"], ["eyepatch"], ["falcon"], ["fan"], ["faucet", "spigot", "tap"], ["fedora"], ["ferret"], ["Ferris wheel"], ["ferry", "ferryboat"], ["fig", "fig fruit"], ["fighter jet", "fighter aircraft", "attack aircraft"], ["figurine"], ["file cabinet", "filing cabinet"], ["file", "file tool"], ["fire alarm", "smoke alarm"], ["fire engine", "fire truck"], ["fire extinguisher", "extinguisher"], ["fire hose"], ["fireplace"], ["fireplug", "fire hydrant", "hydrant"], ["first-aid kit"], ["fish"], ["fish", "fish food"], ["fishbowl", "goldfish bowl"], ["fishing rod", "fishing pole"], ["flag"], ["flagpole", "flagstaff"], ["flamingo"], ["flannel"], ["flap"], ["flash", "flashbulb"], ["flashlight", "torch"], ["fleece"], ["flip-flop", "flip-flop sandal"], ["flipper", "flipper footwear", "fin", "fin footwear"], ["flower arrangement", "floral arrangement"], ["flute glass", "champagne flute"], ["foal"], ["folding chair"], ["food processor"], ["football", "football American"], ["football helmet"], ["footstool", "footrest"], ["fork"], ["forklift"], ["freight car"], ["French toast"], ["freshener", "air freshener"], ["frisbee"], ["frog", "toad", "toad frog"], ["fruit juice"], ["frying pan", "frypan", "skillet"], ["fudge"], ["funnel"], ["futon"], ["gag", "muzzle"], ["garbage"], ["garbage truck"], ["garden hose"], ["gargle", "mouthwash"], ["gargoyle"], ["garlic", "ail"], ["gasmask", "respirator", "gas helmet"], ["gazelle"], ["gelatin", "jelly"], ["gemstone"], ["generator"], ["giant panda", "panda", "panda bear"], ["gift wrap"], ["ginger", "gingerroot"], ["giraffe"], ["cincture", "sash", "waistband", "waistcloth"], ["glass", "glass drink container", "drinking glass"], ["globe"], ["glove"], ["goat"], ["goggles"], ["goldfish"], ["golf club", "golf-club"], ["golfcart"], ["gondola", "gondola boat"], ["goose"], ["gorilla"], ["gourd"], ["grape"], ["grater"], ["gravestone", "headstone", "tombstone"], ["gravy boat", "gravy holder"], ["green bean"], ["green onion", "spring onion", "scallion"], ["griddle"], ["grill", "grille", "grillwork", "radiator grille"], ["grits", "hominy grits"], ["grizzly", "grizzly bear"], ["grocery bag"], ["guitar"], ["gull", "seagull"], ["gun"], ["hairbrush"], ["hairnet"], ["hairpin"], ["halter top"], ["ham", "jambon", "gammon"], ["hamburger", "beefburger", "burger"], ["hammer"], ["hammock"], ["hamper"], ["hamster"], ["hair dryer"], ["hand glass", "hand mirror"], ["hand towel", "face towel"], ["handcart", "pushcart", "hand truck"], ["handcuff"], ["handkerchief"], ["handle", "grip", "handgrip"], ["handsaw", "carpenter's saw"], ["hardback book", "hardcover book"], ["harmonium", "organ", "organ musical instrument", "reed organ", "reed organ musical instrument"], ["hat"], ["hatbox"], ["veil"], ["headband"], ["headboard"], ["headlight", "headlamp"], ["headscarf"], ["headset"], ["headstall", "headstall for horses", "headpiece", "headpiece for horses"], ["heart"], ["heater", "warmer"], ["helicopter"], ["helmet"], ["heron"], ["highchair", "feeding chair"], ["hinge"], ["hippopotamus"], ["hockey stick"], ["hog", "pig"], ["home plate", "home plate baseball", "home base", "home base baseball"], ["honey"], ["fume hood", "exhaust hood"], ["hook"], ["hookah", "narghile", "nargileh", "sheesha", "shisha", "water pipe"], ["hornet"], ["horse"], ["hose", "hosepipe"], ["hot-air balloon"], ["hotplate"], ["hot sauce"], ["hourglass"], ["houseboat"], ["hummingbird"], ["hummus", "humus", "hommos", "hoummos", "humous"], ["polar bear"], ["icecream"], ["popsicle"], ["ice maker"], ["ice pack", "ice bag"], ["ice skate"], ["igniter", "ignitor", "lighter"], ["inhaler", "inhalator"], ["iPod"], ["iron", "iron for clothing", "smoothing iron", "smoothing iron for clothing"], ["ironing board"], ["jacket"], ["jam"], ["jar"], ["jean", "blue jean", "denim"], ["jeep", "landrover"], ["jelly bean", "jelly egg"], ["jersey", "T-shirt", "tee shirt"], ["jet plane", "jet-propelled plane"], ["jewel", "gem", "precious stone"], ["jewelry", "jewellery"], ["joystick"], ["jumpsuit"], ["kayak"], ["keg"], ["kennel", "doghouse"], ["kettle", "boiler"], ["key"], ["keycard"], ["kilt"], ["kimono"], ["kitchen sink"], ["kitchen table"], ["kite"], ["kitten", "kitty"], ["kiwi fruit"], ["knee pad"], ["knife"], ["knitting needle"], ["knob"], ["knocker", "knocker on a door", "doorknocker"], ["koala", "koala bear"], ["lab coat", "laboratory coat"], ["ladder"], ["ladle"], ["ladybug", "ladybeetle", "ladybird beetle"], ["lamb", "lamb animal"], ["lamb-chop", "lambchop"], ["lamp"], ["lamppost"], ["lampshade"], ["lantern"], ["lanyard", "laniard"], ["laptop computer", "notebook computer"], ["lasagna", "lasagne"], ["latch"], ["lawn mower"], ["leather"], ["legging", "legging clothing", "leging", "leging clothing", "leg covering"], ["Lego", "Lego set"], ["legume"], ["lemon"], ["lemonade"], ["lettuce"], ["license plate", "numberplate"], ["life buoy", "lifesaver", "life belt", "life ring"], ["life jacket", "life vest"], ["lightbulb"], ["lightning rod", "lightning conductor"], ["lime"], ["limousine"], ["lion"], ["lip balm"], ["liquor", "spirits", "hard liquor", "liqueur", "cordial"], ["lizard"], ["log"], ["lollipop"], ["speaker", "speaker stereo equipment"], ["loveseat"], ["machine gun"], ["magazine"], ["magnet"], ["mail slot"], ["mailbox", "mailbox at home", "letter box", "letter box at home"], ["mallard"], ["mallet"], ["mammoth"], ["manatee"], ["mandarin orange"], ["manger", "trough"], ["manhole"], ["map"], ["marker"], ["martini"], ["mascot"], ["mashed potato"], ["masher"], ["mask", "facemask"], ["mast"], ["mat", "mat gym equipment", "gym mat"], ["matchbox"], ["mattress"], ["measuring cup"], ["measuring stick", "ruler", "ruler measuring stick", "measuring rod"], ["meatball"], ["medicine"], ["melon"], ["microphone"], ["microscope"], ["microwave oven"], ["milestone", "milepost"], ["milk"], ["milk can"], ["milkshake"], ["minivan"], ["mint candy"], ["mirror"], ["mitten"], ["mixer", "mixer kitchen tool", "stand mixer"], ["money"], ["monitor", "monitor computer equipment"], ["monkey"], ["motor"], ["motor scooter", "scooter"], ["motor vehicle", "automotive vehicle"], ["motorcycle"], ["mound", "mound baseball", "pitcher's mound"], ["mouse", "mouse computer equipment", "computer mouse"], ["mousepad"], ["muffin"], ["mug"], ["mushroom"], ["music stool", "piano stool"], ["musical instrument", "instrument", "instrument musical"], ["nailfile"], ["napkin", "table napkin", "serviette"], ["neckerchief"], ["necklace"], ["necktie", "tie", "tie necktie"], ["needle"], ["nest"], ["newspaper", "paper", "paper newspaper"], ["newsstand"], ["nightshirt", "nightwear", "sleepwear", "nightclothes"], ["nosebag", "nosebag for animals", "feedbag"], ["noseband", "noseband for animals", "nosepiece", "nosepiece for animals"], ["notebook"], ["notepad"], ["nut"], ["nutcracker"], ["oar"], ["octopus", "octopus food"], ["octopus", "octopus animal"], ["oil lamp", "kerosene lamp", "kerosine lamp"], ["olive oil"], ["omelet", "omelette"], ["onion"], ["orange", "orange fruit"], ["orange juice"], ["ostrich"], ["ottoman", "pouf", "pouffe", "hassock"], ["oven"], ["overalls", "overalls clothing"], ["owl"], ["packet"], ["inkpad", "inking pad", "stamp pad"], ["pad"], ["paddle", "boat paddle"], ["padlock"], ["paintbrush"], ["painting"], ["pajamas", "pyjamas"], ["palette", "pallet"], ["pan", "pan for cooking", "cooking pan"], ["pan", "pan metal container"], ["pancake"], ["pantyhose"], ["papaya"], ["paper plate"], ["paper towel"], ["paperback book", "paper-back book", "softback book", "soft-cover book"], ["paperweight"], ["parachute"], ["parakeet", "parrakeet", "parroket", "paraquet", "paroquet", "parroquet"], ["parasail", "parasail sports"], ["parasol", "sunshade"], ["parchment"], ["parka", "anorak"], ["parking meter"], ["parrot"], ["passenger car", "passenger car part of a train", "coach", "coach part of a train"], ["passenger ship"], ["passport"], ["pastry"], ["patty", "patty food"], ["pea", "pea food"], ["peach"], ["peanut butter"], ["pear"], ["peeler", "peeler tool for fruit and vegetables"], ["wooden leg", "pegleg"], ["pegboard"], ["pelican"], ["pen"], ["pencil"], ["pencil box", "pencil case"], ["pencil sharpener"], ["pendulum"], ["penguin"], ["pennant"], ["penny", "penny coin"], ["pepper", "peppercorn"], ["pepper mill", "pepper grinder"], ["perfume"], ["persimmon"], ["person", "baby", "child", "boy", "girl", "man", "woman", "human"], ["pet"], ["pew", "pew church bench", "church bench"], ["phonebook", "telephone book", "telephone directory"], ["phonograph record", "phonograph recording", "record", "record phonograph recording"], ["piano"], ["pickle"], ["pickup truck"], ["pie"], ["pigeon"], ["piggy bank", "penny bank"], ["pillow"], ["pin", "pin non jewelry"], ["pineapple"], ["pinecone"], ["ping-pong ball"], ["pinwheel"], ["tobacco pipe"], ["pipe", "piping"], ["pistol", "handgun"], ["pita", "pita bread", "pocket bread"], ["pitcher", "pitcher vessel for liquid", "ewer"], ["pitchfork"], ["pizza"], ["place mat"], ["plate"], ["platter"], ["playpen"], ["pliers", "plyers"], ["plow", "plow farm equipment", "plough", "plough farm equipment"], ["plume"], ["pocket watch"], ["pocketknife"], ["poker", "poker fire stirring tool", "stove poker", "fire hook"], ["pole", "post"], ["polo shirt", "sport shirt"], ["poncho"], ["pony"], ["pool table", "billiard table", "snooker table"], ["pop", "pop soda", "soda", "soda pop", "tonic", "soft drink"], ["postbox", "postbox public", "mailbox", "mailbox public"], ["postcard", "postal card", "mailing-card"], ["poster", "placard"], ["pot"], ["flowerpot"], ["potato"], ["potholder"], ["pottery", "clayware"], ["pouch"], ["power shovel", "excavator", "digger"], ["prawn", "shrimp"], ["pretzel"], ["printer", "printing machine"], ["projectile", "projectile weapon", "missile"], ["projector"], ["propeller", "propellor"], ["prune"], ["pudding"], ["puffer", "puffer fish", "pufferfish", "blowfish", "globefish"], ["puffin"], ["pug-dog"], ["pumpkin"], ["puncher"], ["puppet", "marionette"], ["puppy"], ["quesadilla"], ["quiche"], ["quilt", "comforter"], ["rabbit"], ["race car", "racing car"], ["racket", "racquet"], ["radar"], ["radiator"], ["radio receiver", "radio set", "radio", "tuner", "tuner radio"], ["radish", "daikon"], ["raft"], ["rag doll"], ["raincoat", "waterproof jacket"], ["ram", "ram animal"], ["raspberry"], ["rat"], ["razorblade"], ["reamer", "reamer juicer", "juicer", "juice reamer"], ["rearview mirror"], ["receipt"], ["recliner", "reclining chair", "lounger", "lounger chair"], ["record player", "phonograph", "phonograph record player", "turntable"], ["reflector"], ["remote control"], ["rhinoceros"], ["rib", "rib food"], ["rifle"], ["ring"], ["river boat"], ["road map"], ["robe"], ["rocking chair"], ["rodent"], ["roller skate"], ["Rollerblade"], ["rolling pin"], ["root beer"], ["router", "router computer equipment"], ["rubber band", "elastic band"], ["runner", "runner carpet"], ["plastic bag", "paper bag"], ["saddle", "saddle on an animal"], ["saddle blanket", "saddlecloth", "horse blanket"], ["saddlebag"], ["safety pin"], ["sail"], ["salad"], ["salad plate", "salad bowl"], ["salami"], ["salmon", "salmon fish"], ["salmon", "salmon food"], ["salsa"], ["saltshaker"], ["sandal", "sandal type of shoe"], ["sandwich"], ["satchel"], ["saucepan"], ["saucer"], ["sausage"], ["sawhorse", "sawbuck"], ["saxophone"], ["scale", "scale measuring instrument"], ["scarecrow", "strawman"], ["scarf"], ["school bus"], ["scissors"], ["scoreboard"], ["scraper"], ["screwdriver"], ["scrubbing brush"], ["sculpture"], ["seabird", "seafowl"], ["seahorse"], ["seaplane", "hydroplane"], ["seashell"], ["sewing machine"], ["shaker"], ["shampoo"], ["shark"], ["sharpener"], ["Sharpie"], ["shaver", "shaver electric", "electric shaver", "electric razor"], ["shaving cream", "shaving soap"], ["shawl"], ["shears"], ["sheep"], ["shepherd dog", "sheepdog"], ["sherbert", "sherbet"], ["shield"], ["shirt"], ["shoe", "sneaker", "sneaker type of shoe", "tennis shoe"], ["shopping bag"], ["shopping cart"], ["short pants", "shorts", "shorts clothing", "trunks", "trunks clothing"], ["shot glass"], ["shoulder bag"], ["shovel"], ["shower head"], ["shower cap"], ["shower curtain"], ["shredder", "shredder for paper"], ["signboard"], ["silo"], ["sink"], ["skateboard"], ["skewer"], ["ski"], ["ski boot"], ["ski parka", "ski jacket"], ["ski pole"], ["skirt"], ["skullcap"], ["sled", "sledge", "sleigh"], ["sleeping bag"], ["sling", "sling bandage", "triangular bandage"], ["slipper", "slipper footwear", "carpet slipper", "carpet slipper footwear"], ["smoothie"], ["snake", "serpent"], ["snowboard"], ["snowman"], ["snowmobile"], ["soap"], ["soccer ball"], ["sock"], ["sofa", "couch", "lounge"], ["softball"], ["solar array", "solar battery", "solar panel"], ["sombrero"], ["soup"], ["soup bowl"], ["soupspoon"], ["sour cream", "soured cream"], ["soya milk", "soybean milk", "soymilk"], ["space shuttle"], ["sparkler", "sparkler fireworks"], ["spatula"], ["spear", "lance"], ["spectacles", "specs", "eyeglasses", "glasses"], ["spice rack"], ["spider"], ["crawfish", "crayfish"], ["sponge"], ["spoon"], ["sportswear", "athletic wear", "activewear"], ["spotlight"], ["squid", "squid food", "calamari", "calamary"], ["squirrel"], ["stagecoach"], ["stapler", "stapler stapling machine"], ["starfish", "sea star"], ["statue", "statue sculpture"], ["steak", "steak food"], ["steak knife"], ["steering wheel"], ["stepladder"], ["step stool"], ["stereo", "stereo sound system"], ["stew"], ["stirrer"], ["stirrup"], ["stool"], ["stop sign"], ["brake light"], ["stove", "kitchen stove", "range", "range kitchen appliance", "kitchen range", "cooking stove"], ["strainer"], ["strap"], ["straw", "straw for drinking", "drinking straw"], ["strawberry"], ["street sign"], ["streetlight", "street lamp"], ["string cheese"], ["stylus"], ["subwoofer"], ["sugar bowl"], ["sugarcane", "sugarcane plant"], ["suit", "suit clothing"], ["sunflower"], ["sunglasses"], ["sunhat"], ["surfboard"], ["sushi"], ["mop"], ["sweat pants"], ["sweatband"], ["sweater"], ["sweatshirt"], ["sweet potato"], ["swimsuit", "swimwear", "bathing suit", "swimming costume", "bathing costume", "swimming trunks", "bathing trunks"], ["sword"], ["syringe"], ["Tabasco sauce"], ["table-tennis table", "ping-pong table"], ["table"], ["table lamp"], ["tablecloth"], ["tachometer"], ["taco"], ["tag"], ["taillight", "rear light"], ["tambourine"], ["army tank", "armored combat vehicle", "armoured combat vehicle"], ["tank", "tank storage vessel", "storage tank"], ["tank top", "tank top clothing"], ["tape", "tape sticky cloth or paper"], ["tape measure", "measuring tape"], ["tapestry"], ["tarp"], ["tartan", "plaid"], ["tassel"], ["tea bag"], ["teacup"], ["teakettle"], ["teapot"], ["teddy bear"], ["telephone", "phone", "telephone set"], ["telephone booth", "phone booth", "call box", "telephone box", "telephone kiosk"], ["telephone pole", "telegraph pole", "telegraph post"], ["telephoto lens", "zoom lens"], ["television camera", "tv camera"], ["television set", "tv", "tv set"], ["tennis ball"], ["tennis racket"], ["tequila"], ["thermometer"], ["thermos bottle"], ["thermostat"], ["thimble"], ["thread", "yarn"], ["thumbtack", "drawing pin", "pushpin"], ["tiara"], ["tiger"], ["tights", "tights clothing", "leotards"], ["timer", "stopwatch"], ["tinfoil"], ["tinsel"], ["tissue paper"], ["toast", "toast food"], ["toaster"], ["toaster oven"], ["toilet"], ["toilet tissue", "toilet paper", "bathroom tissue"], ["tomato"], ["tongs"], ["toolbox"], ["toothbrush"], ["toothpaste"], ["toothpick"], ["cover"], ["tortilla"], ["tow truck"], ["towel"], ["towel rack", "towel rail", "towel bar"], ["toy"], ["tractor", "tractor farm equipment"], ["traffic light"], ["dirt bike"], ["trailer truck", "tractor trailer", "trucking rig", "articulated lorry", "semi truck"], ["train", "train railroad vehicle", "railroad train"], ["trampoline"], ["tray"], ["trench coat"], ["triangle", "triangle musical instrument"], ["tricycle"], ["tripod"], ["trousers", "pants", "pants clothing"], ["truck"], ["truffle", "truffle chocolate", "chocolate truffle"], ["trunk"], ["vat"], ["turban"], ["turkey", "turkey food"], ["turnip"], ["turtle"], ["turtleneck", "turtleneck clothing", "polo-neck"], ["typewriter"], ["umbrella"], ["underwear", "underclothes", "underclothing", "underpants"], ["unicycle"], ["urinal"], ["urn"], ["vacuum cleaner"], ["vase"], ["vending machine"], ["vent", "blowhole", "air vent"], ["vest", "waistcoat"], ["videotape"], ["vinegar"], ["violin", "fiddle"], ["vodka"], ["volleyball"], ["vulture"], ["waffle"], ["waffle iron"], ["wagon"], ["wagon wheel"], ["walking stick"], ["wall clock"], ["wall socket", "wall plug", "electric outlet", "electrical outlet", "outlet", "electric receptacle"], ["wallet", "billfold"], ["walrus"], ["wardrobe"], ["washbasin", "basin", "basin for washing", "washbowl", "washstand", "handbasin"], ["automatic washer", "washing machine"], ["watch", "wristwatch"], ["water bottle"], ["water cooler"], ["water faucet", "water tap", "tap", "tap water faucet"], ["water heater", "hot-water heater"], ["water jug"], ["water gun", "squirt gun"], ["water scooter", "sea scooter", "jet ski"], ["water ski"], ["water tower"], ["watering can"], ["watermelon"], ["weathervane", "vane", "vane weathervane", "wind vane"], ["webcam"], ["wedding cake", "bridecake"], ["wedding ring", "wedding band"], ["wet suit"], ["wheel"], ["wheelchair"], ["whipped cream"], ["whistle"], ["wig"], ["wind chime"], ["windmill"], ["window box", "window box for plants"], ["windshield wiper", "windscreen wiper", "wiper", "wiper for windshield or screen"], ["windsock", "air sock", "air-sleeve", "wind sleeve", "wind cone"], ["wine bottle"], ["wine bucket", "wine cooler"], ["wineglass"], ["blinder", "blinder for horses"], ["wok"], ["wolf"], ["wooden spoon"], ["wreath"], ["wrench", "spanner"], ["wristband"], ["wristlet", "wrist band"], ["yacht"], ["yogurt", "yoghurt", "yoghourt"], ["yoke", "yoke animal equipment"], ["zebra"], ["zucchini", "courgette"]] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/obj365v1_class_texts.json b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/obj365v1_class_texts.json new file mode 100644 index 0000000000000000000000000000000000000000..bddc11c0b9721bb4b7addc9a557a2eed1c9fe0fc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/data/texts/obj365v1_class_texts.json @@ -0,0 +1 @@ +[["person"], ["sneakers"], ["chair"], ["hat"], ["lamp"], ["bottle"], ["cabinet", "shelf"], ["cup"], ["car"], ["glasses"], ["picture", "frame"], ["desk"], ["handbag"], ["street lights"], ["book"], ["plate"], ["helmet"], ["leather shoes"], ["pillow"], ["glove"], ["potted plant"], ["bracelet"], ["flower"], ["tv"], ["storage box"], ["vase"], ["bench"], ["wine glass"], ["boots"], ["bowl"], ["dining table"], ["umbrella"], ["boat"], ["flag"], ["speaker"], ["trash bin", "can"], ["stool"], ["backpack"], ["couch"], ["belt"], ["carpet"], ["basket"], ["towel", "napkin"], ["slippers"], ["barrel", "bucket"], ["coffee table"], ["suv"], ["toy"], ["tie"], ["bed"], ["traffic light"], ["pen", "pencil"], ["microphone"], ["sandals"], ["canned"], ["necklace"], ["mirror"], ["faucet"], ["bicycle"], ["bread"], ["high heels"], ["ring"], ["van"], ["watch"], ["sink"], ["horse"], ["fish"], ["apple"], ["camera"], ["candle"], ["teddy bear"], ["cake"], ["motorcycle"], ["wild bird"], ["laptop"], ["knife"], ["traffic sign"], ["cell phone"], ["paddle"], ["truck"], ["cow"], ["power outlet"], ["clock"], ["drum"], ["fork"], ["bus"], ["hanger"], ["nightstand"], ["pot", "pan"], ["sheep"], ["guitar"], ["traffic cone"], ["tea pot"], ["keyboard"], ["tripod"], ["hockey"], ["fan"], ["dog"], ["spoon"], ["blackboard", "whiteboard"], ["balloon"], ["air conditioner"], ["cymbal"], ["mouse"], ["telephone"], ["pickup truck"], ["orange"], ["banana"], ["airplane"], ["luggage"], ["skis"], ["soccer"], ["trolley"], ["oven"], ["remote"], ["baseball glove"], ["paper towel"], ["refrigerator"], ["train"], ["tomato"], ["machinery vehicle"], ["tent"], ["shampoo", "shower gel"], ["head phone"], ["lantern"], ["donut"], ["cleaning products"], ["sailboat"], ["tangerine"], ["pizza"], ["kite"], ["computer box"], ["elephant"], ["toiletries"], ["gas stove"], ["broccoli"], ["toilet"], ["stroller"], ["shovel"], ["baseball bat"], ["microwave"], ["skateboard"], ["surfboard"], ["surveillance camera"], ["gun"], ["life saver"], ["cat"], ["lemon"], ["liquid soap"], ["zebra"], ["duck"], ["sports car"], ["giraffe"], ["pumpkin"], ["piano"], ["stop sign"], ["radiator"], ["converter"], ["tissue"], ["carrot"], ["washing machine"], ["vent"], ["cookies"], ["cutting", "chopping board"], ["tennis racket"], ["candy"], ["skating and skiing shoes"], ["scissors"], ["folder"], ["baseball"], ["strawberry"], ["bow tie"], ["pigeon"], ["pepper"], ["coffee machine"], ["bathtub"], ["snowboard"], ["suitcase"], ["grapes"], ["ladder"], ["pear"], ["american football"], ["basketball"], ["potato"], ["paint brush"], ["printer"], ["billiards"], ["fire hydrant"], ["goose"], ["projector"], ["sausage"], ["fire extinguisher"], ["extension cord"], ["facial mask"], ["tennis ball"], ["chopsticks"], ["electronic stove and gas stove"], ["pie"], ["frisbee"], ["kettle"], ["hamburger"], ["golf club"], ["cucumber"], ["clutch"], ["blender"], ["tong"], ["slide"], ["hot dog"], ["toothbrush"], ["facial cleanser"], ["mango"], ["deer"], ["egg"], ["violin"], ["marker"], ["ship"], ["chicken"], ["onion"], ["ice cream"], ["tape"], ["wheelchair"], ["plum"], ["bar soap"], ["scale"], ["watermelon"], ["cabbage"], ["router", "modem"], ["golf ball"], ["pine apple"], ["crane"], ["fire truck"], ["peach"], ["cello"], ["notepaper"], ["tricycle"], ["toaster"], ["helicopter"], ["green beans"], ["brush"], ["carriage"], ["cigar"], ["earphone"], ["penguin"], ["hurdle"], ["swing"], ["radio"], ["cd"], ["parking meter"], ["swan"], ["garlic"], ["french fries"], ["horn"], ["avocado"], ["saxophone"], ["trumpet"], ["sandwich"], ["cue"], ["kiwi fruit"], ["bear"], ["fishing rod"], ["cherry"], ["tablet"], ["green vegetables"], ["nuts"], ["corn"], ["key"], ["screwdriver"], ["globe"], ["broom"], ["pliers"], ["volleyball"], ["hammer"], ["eggplant"], ["trophy"], ["dates"], ["board eraser"], ["rice"], ["tape measure", "ruler"], ["dumbbell"], ["hamimelon"], ["stapler"], ["camel"], ["lettuce"], ["goldfish"], ["meat balls"], ["medal"], ["toothpaste"], ["antelope"], ["shrimp"], ["rickshaw"], ["trombone"], ["pomegranate"], ["coconut"], ["jellyfish"], ["mushroom"], ["calculator"], ["treadmill"], ["butterfly"], ["egg tart"], ["cheese"], ["pig"], ["pomelo"], ["race car"], ["rice cooker"], ["tuba"], ["crosswalk sign"], ["papaya"], ["hair drier"], ["green onion"], ["chips"], ["dolphin"], ["sushi"], ["urinal"], ["donkey"], ["electric drill"], ["spring rolls"], ["tortoise", "turtle"], ["parrot"], ["flute"], ["measuring cup"], ["shark"], ["steak"], ["poker card"], ["binoculars"], ["llama"], ["radish"], ["noodles"], ["yak"], ["mop"], ["crab"], ["microscope"], ["barbell"], ["bread", "bun"], ["baozi"], ["lion"], ["red cabbage"], ["polar bear"], ["lighter"], ["seal"], ["mangosteen"], ["comb"], ["eraser"], ["pitaya"], ["scallop"], ["pencil case"], ["saw"], ["table tennis paddle"], ["okra"], ["starfish"], ["eagle"], ["monkey"], ["durian"], ["game board"], ["rabbit"], ["french horn"], ["ambulance"], ["asparagus"], ["hoverboard"], ["pasta"], ["target"], ["hotair balloon"], ["chainsaw"], ["lobster"], ["iron"], ["flashlight"]] \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c6f607c5044ecb85c52cc5254006382bb648a4b1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/README.md @@ -0,0 +1,65 @@ +## YOLO-World Demo + +### Getting Started + +Setting `PYTHONPATH` as the path to `YOLO-World` and run: + +```bash +PYTHONPATH=/xxxx/YOLO-World python demo/yyyy_demo.py +# or directly +PYTHONPATH=./ python demo/yyyy_demo.py +``` + +#### Gradio Demo + +We provide the [Gradio](https://www.gradio.app/) demo for local devices: + +```bash +pip install gradio==4.16.0 +python demo/demo.py path/to/config path/to/weights +``` + +Additionaly, you can use a Dockerfile to build an image with gradio. As a prerequisite, make sure you have respective drivers installed alongside [nvidia-container-runtime](https://stackoverflow.com/questions/59691207/docker-build-with-nvidia-runtime). Replace MODEL_NAME and WEIGHT_NAME with the respective values or ommit this and use default values from the [Dockerfile](Dockerfile#3) + +```bash +docker build --build-arg="MODEL=MODEL_NAME" --build-arg="WEIGHT=WEIGHT_NAME" -t yolo_demo . +docker run --runtime nvidia -p 8080:8080 +``` + +#### Image Demo + +We provide a simple image demo for inference on images with visualization outputs. + +```bash +python demo/image_demo.py path/to/config path/to/weights image/path/directory 'person,dog,cat' --topk 100 --threshold 0.005 --output-dir demo_outputs +``` + +**Notes:** +* The `image` can be a directory or a single image. +* The `texts` can be a string of categories (noun phrases) which is separated by a comma. We also support `txt` file in which each line contains a category ( noun phrases). +* The `topk` and `threshold` control the number of predictions and the confidence threshold. + + +#### Video Demo + +The `video_demo` has similar hyper-parameters with `image_demo`. + +```bash +python demo/video_demo.py path/to/config path/to/weights video_path 'person,dog' --out out_video_path +``` + +### FAQ + +> 1. `Failed to custom import!` +```bash + File "simple_demo.py", line 37, in + cfg = Config.fromfile(config_file) + File "/data/miniconda3/envs/det/lib/python3.8/site-packages/mmengine/config/config.py", line 183, in fromfile + raise ImportError('Failed to custom import!') from e +ImportError: Failed to custom import! +``` +**Solution:** + +```bash +PYTHONPATH=/xxxx/YOLO-World python demo/simple_demo.py +``` \ No newline at end of file diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/gradio_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/gradio_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..739e97beaa8641885f25fa2a4d1bdcbbfc95c20e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/gradio_demo.py @@ -0,0 +1,253 @@ +# Copyright (c) Tencent Inc. All rights reserved. +import os +import sys +import argparse +import os.path as osp +from io import BytesIO +from functools import partial + +import cv2 +import onnx +import torch +import onnxsim +import numpy as np +import gradio as gr +from PIL import Image +import supervision as sv +from torchvision.ops import nms +from mmengine.runner import Runner +from mmengine.dataset import Compose +from mmengine.runner.amp import autocast +from mmengine.config import Config, DictAction, ConfigDict +from mmdet.datasets import CocoDataset +from mmyolo.registry import RUNNERS + +sys.path.append('./deploy') +from easydeploy import model as EM + +BOUNDING_BOX_ANNOTATOR = sv.BoundingBoxAnnotator(thickness=1) +MASK_ANNOTATOR = sv.MaskAnnotator() + + +class LabelAnnotator(sv.LabelAnnotator): + + @staticmethod + def resolve_text_background_xyxy( + center_coordinates, + text_wh, + position, + ): + center_x, center_y = center_coordinates + text_w, text_h = text_wh + return center_x, center_y, center_x + text_w, center_y + text_h + + +LABEL_ANNOTATOR = LabelAnnotator(text_padding=4, + text_scale=0.5, + text_thickness=1) + + +def parse_args(): + parser = argparse.ArgumentParser(description='YOLO-World Demo') + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint', help='checkpoint file') + parser.add_argument( + '--work-dir', + help='the directory to save the file containing evaluation metrics', + default='output') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + args = parser.parse_args() + return args + + +def run_image(runner, + image, + text, + max_num_boxes, + score_thr, + nms_thr, + image_path='./work_dirs/demo.png'): + # image.save(image_path) + texts = [[t.strip()] for t in text.split(',')] + [[' ']] + data_info = dict(img_id=0, img=np.array(image), texts=texts) + data_info = runner.pipeline(data_info) + data_batch = dict(inputs=data_info['inputs'].unsqueeze(0), + data_samples=[data_info['data_samples']]) + + with autocast(enabled=False), torch.no_grad(): + output = runner.model.test_step(data_batch)[0] + pred_instances = output.pred_instances + + keep = nms(pred_instances.bboxes, + pred_instances.scores, + iou_threshold=nms_thr) + pred_instances = pred_instances[keep] + pred_instances = pred_instances[pred_instances.scores.float() > score_thr] + + if len(pred_instances.scores) > max_num_boxes: + indices = pred_instances.scores.float().topk(max_num_boxes)[1] + pred_instances = pred_instances[indices] + + pred_instances = pred_instances.cpu().numpy() + if 'masks' in pred_instances: + masks = pred_instances['masks'] + else: + masks = None + detections = sv.Detections(xyxy=pred_instances['bboxes'], + class_id=pred_instances['labels'], + confidence=pred_instances['scores'], + mask=masks) + labels = [ + f"{texts[class_id][0]} {confidence:0.2f}" for class_id, confidence in + zip(detections.class_id, detections.confidence) + ] + + image = np.array(image) + image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) # Convert RGB to BGR + image = BOUNDING_BOX_ANNOTATOR.annotate(image, detections) + image = LABEL_ANNOTATOR.annotate(image, detections, labels=labels) + if masks is not None: + image = MASK_ANNOTATOR.annotate(image, detections) + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # Convert BGR to RGB + image = Image.fromarray(image) + return image + + +def export_model(runner, text, max_num_boxes, score_thr, nms_thr): + + backend = EM.MMYOLOBackend.ONNXRUNTIME + postprocess_cfg = ConfigDict(pre_top_k=10 * max_num_boxes, + keep_top_k=max_num_boxes, + iou_threshold=nms_thr, + score_threshold=score_thr) + + base_model = runner.model + + texts = [[t.strip() for t in text.split(',')] + [' ']] + base_model.reparameterize(texts) + deploy_model = EM.DeployModel(baseModel=base_model, + backend=backend, + postprocess_cfg=postprocess_cfg) + deploy_model.eval() + + device = (next(iter(base_model.parameters()))).device + fake_input = torch.ones([1, 3, 640, 640], device=device) + deploy_model(fake_input) + + save_onnx_path = os.path.join( + args.work_dir, + os.path.basename(args.checkpoint).replace('pth', 'onnx')) + # export onnx + with BytesIO() as f: + output_names = ['num_dets', 'boxes', 'scores', 'labels'] + torch.onnx.export(deploy_model, + fake_input, + f, + input_names=['images'], + output_names=output_names, + opset_version=12) + f.seek(0) + onnx_model = onnx.load(f) + onnx.checker.check_model(onnx_model) + onnx_model, check = onnxsim.simplify(onnx_model) + onnx.save(onnx_model, save_onnx_path) + return gr.update(visible=True), save_onnx_path + + +def demo(runner, args): + with gr.Blocks(title="YOLO-World") as demo: + with gr.Row(): + gr.Markdown('

YOLO-World: Real-Time Open-Vocabulary ' + 'Object Detector

') + with gr.Row(): + with gr.Column(scale=0.3): + with gr.Row(): + image = gr.Image(type='pil', label='input image') + input_text = gr.Textbox( + lines=7, + label='Enter the classes to be detected, ' + 'separated by comma', + value=', '.join(CocoDataset.METAINFO['classes']), + elem_id='textbox') + with gr.Row(): + submit = gr.Button('Submit') + clear = gr.Button('Clear') + with gr.Row(): + export = gr.Button('Deploy and Export ONNX Model') + with gr.Row(): + gr.Markdown( + "It takes a few seconds to generate the ONNX file! YOLO-World-Seg (segmentation) is not supported now" + ) + out_download = gr.File(visible=False) + max_num_boxes = gr.Slider(minimum=1, + maximum=300, + value=100, + step=1, + interactive=True, + label='Maximum Number Boxes') + score_thr = gr.Slider(minimum=0, + maximum=1, + value=0.05, + step=0.001, + interactive=True, + label='Score Threshold') + nms_thr = gr.Slider(minimum=0, + maximum=1, + value=0.7, + step=0.001, + interactive=True, + label='NMS Threshold') + with gr.Column(scale=0.7): + output_image = gr.Image(type='pil', label='output image') + + submit.click(partial(run_image, runner), + [image, input_text, max_num_boxes, score_thr, nms_thr], + [output_image]) + clear.click(lambda: [None, '', None], None, + [image, input_text, output_image]) + + export.click(partial(export_model, runner), + [input_text, max_num_boxes, score_thr, nms_thr], + [out_download, out_download]) + + demo.launch(server_name='0.0.0.0', + server_port=8080) # port 80 does not work for me + + +if __name__ == '__main__': + args = parse_args() + + # load config + cfg = Config.fromfile(args.config) + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + if args.work_dir is not None: + cfg.work_dir = args.work_dir + elif cfg.get('work_dir', None) is None: + cfg.work_dir = osp.join('./work_dirs', + osp.splitext(osp.basename(args.config))[0]) + + cfg.load_from = args.checkpoint + + if 'runner_type' not in cfg: + runner = Runner.from_cfg(cfg) + else: + runner = RUNNERS.build(cfg) + + runner.call_hook('before_run') + runner.load_or_resume() + pipeline = cfg.test_dataloader.dataset.pipeline + pipeline[0].type = 'mmdet.LoadImageFromNDArray' + runner.pipeline = Compose(pipeline) + runner.model.eval() + demo(runner, args) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/image_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/image_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..2f78d729d131824c844a6dd37b9f5c874f53e478 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/image_demo.py @@ -0,0 +1,220 @@ +# Copyright (c) Tencent Inc. All rights reserved. +import os +import cv2 +import argparse +import os.path as osp + +import torch +from mmengine.config import Config, DictAction +from mmengine.runner.amp import autocast +from mmengine.dataset import Compose +from mmengine.utils import ProgressBar +from mmdet.apis import init_detector +from mmdet.utils import get_test_pipeline_cfg +import supervision as sv +import warnings +warnings.filterwarnings("ignore") + +BOUNDING_BOX_ANNOTATOR = sv.BoundingBoxAnnotator(thickness=1) +MASK_ANNOTATOR = sv.MaskAnnotator() + + +class LabelAnnotator(sv.LabelAnnotator): + + @staticmethod + def resolve_text_background_xyxy( + center_coordinates, + text_wh, + position, + ): + center_x, center_y = center_coordinates + text_w, text_h = text_wh + return center_x, center_y, center_x + text_w, center_y + text_h + + +LABEL_ANNOTATOR = LabelAnnotator(text_padding=4, + text_scale=0.5, + text_thickness=1) + + +def parse_args(): + parser = argparse.ArgumentParser(description='YOLO-World Demo') + parser.add_argument('--config', help='test config file path') + parser.add_argument('--checkpoint', help='checkpoint file') + parser.add_argument('--image', help='image path, include image file or dir.') + parser.add_argument('--text') + parser.add_argument('--topk', + default=100, + type=int, + help='keep topk predictions.') + parser.add_argument('--threshold', + default=0.7, + type=float, + help='confidence score threshold for predictions.') + parser.add_argument('--device', + default='cuda:0', + help='device used for inference.') + parser.add_argument('--show', + action='store_true', + help='show the detection results.') + parser.add_argument( + '--annotation', + action='store_true', + help='save the annotated detection results as yolo text format.') + parser.add_argument('--amp', + action='store_true', + help='use mixed precision for inference.') + parser.add_argument('--output-dir', + default='demo_outputs', + help='the directory to save outputs') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + args = parser.parse_args() + return args + + +def inference_detector(model, + image, + texts, + test_pipeline, + max_dets=100, + score_thr=0.3, + output_dir='./work_dir', + use_amp=False, + show=False, + annotation=False): + data_info = dict(img_id=0, img_path=image, texts=texts) + data_info = test_pipeline(data_info) + data_batch = dict(inputs=data_info['inputs'].unsqueeze(0), + data_samples=[data_info['data_samples']]) + + with autocast(enabled=use_amp), torch.no_grad(): + output = model.test_step(data_batch)[0] + pred_instances = output.pred_instances + pred_instances = pred_instances[pred_instances.scores.float() > + score_thr] + + if len(pred_instances.scores) > max_dets: + indices = pred_instances.scores.float().topk(max_dets)[1] + pred_instances = pred_instances[indices] + + pred_instances = pred_instances.cpu().numpy() + boxes=pred_instances['bboxes'] + labels=pred_instances['labels'] + print(len(boxes), labels) + + if 'masks' in pred_instances: + masks = pred_instances['masks'] + else: + masks = None + + detections = sv.Detections(xyxy=pred_instances['bboxes'], + class_id=pred_instances['labels'], + confidence=pred_instances['scores'], + mask=masks) + + labels = [ + f"{texts[class_id][0]} {confidence:0.2f}" for class_id, confidence in + zip(detections.class_id, detections.confidence) + ] + + # label images + image = cv2.imread(image_path) + anno_image = image.copy() + image = BOUNDING_BOX_ANNOTATOR.annotate(image, detections) + image = LABEL_ANNOTATOR.annotate(image, detections, labels=labels) + if masks is not None: + image = MASK_ANNOTATOR.annotate(image, detections) + cv2.imwrite(osp.join(output_dir, osp.basename(image_path)), image) + + if annotation: + images_dict = {} + annotations_dict = {} + + images_dict[osp.basename(image_path)] = anno_image + annotations_dict[osp.basename(image_path)] = detections + + ANNOTATIONS_DIRECTORY = os.makedirs(r"./annotations", exist_ok=True) + + MIN_IMAGE_AREA_PERCENTAGE = 0.002 + MAX_IMAGE_AREA_PERCENTAGE = 0.80 + APPROXIMATION_PERCENTAGE = 0.75 + + sv.DetectionDataset( + classes=texts, images=images_dict, + annotations=annotations_dict).as_yolo( + annotations_directory_path=ANNOTATIONS_DIRECTORY, + min_image_area_percentage=MIN_IMAGE_AREA_PERCENTAGE, + max_image_area_percentage=MAX_IMAGE_AREA_PERCENTAGE, + approximation_percentage=APPROXIMATION_PERCENTAGE) + + # if show: + # cv2.imshow('Image', image) # Provide window name + # k = cv2.waitKey(0) + # if k == 27: + # # wait for ESC key to exit + # cv2.destroyAllWindows() + + +if __name__ == '__main__': + args = parse_args() + + # load config + cfg = Config.fromfile(args.config) + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + cfg.work_dir = osp.join('./work_dirs', + osp.splitext(osp.basename(args.config))[0]) + # init model + cfg.load_from = args.checkpoint + model = init_detector(cfg, checkpoint=args.checkpoint, device=args.device) + + # init test pipeline + test_pipeline_cfg = get_test_pipeline_cfg(cfg=cfg) + # test_pipeline[0].type = 'mmdet.LoadImageFromNDArray' + test_pipeline = Compose(test_pipeline_cfg) + + if args.text.endswith('.txt'): + with open(args.text) as f: + lines = f.readlines() + texts = [[t.rstrip('\r\n')] for t in lines] + [[' ']] + else: + texts = [[t.strip()] for t in args.text.split(',')] + [[' ']] + + output_dir = args.output_dir + if not osp.exists(output_dir): + os.mkdir(output_dir) + + # load images + if not osp.isfile(args.image): + images = [ + osp.join(args.image, img) for img in os.listdir(args.image) + if img.endswith('.png') or img.endswith('.jpg') + ] + else: + images = [args.image] + + # reparameterize texts + model.reparameterize(texts) + progress_bar = ProgressBar(len(images)) + for image_path in images: + inference_detector(model, + image_path, + texts, + test_pipeline, + args.topk, + args.threshold, + output_dir=output_dir, + use_amp=args.amp, + show=args.show, + annotation=args.annotation) + progress_bar.update() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/image_prompt_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/image_prompt_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..6011a8a9a96026fc9805109379be6fcfd02295a1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/image_prompt_demo.py @@ -0,0 +1,320 @@ +# Copyright (c) Tencent Inc. All rights reserved. +import os +import sys +import argparse +import os.path as osp +from io import BytesIO +from functools import partial + +import cv2 +# import onnx +import torch +# import onnxsim +import numpy as np +import gradio as gr +from PIL import Image +import supervision as sv +from torchvision.ops import nms +from mmengine.runner import Runner +from mmengine.dataset import Compose +from mmengine.runner.amp import autocast +from mmengine.config import Config, DictAction, ConfigDict +from mmdet.datasets import CocoDataset +from mmyolo.registry import RUNNERS + +from transformers import (AutoTokenizer, CLIPTextModelWithProjection) +from transformers import (AutoProcessor, CLIPVisionModelWithProjection) + +BOUNDING_BOX_ANNOTATOR = sv.BoundingBoxAnnotator(thickness=2) +MASK_ANNOTATOR = sv.MaskAnnotator() + + +class LabelAnnotator(sv.LabelAnnotator): + + @staticmethod + def resolve_text_background_xyxy( + center_coordinates, + text_wh, + position, + ): + center_x, center_y = center_coordinates + text_w, text_h = text_wh + return center_x, center_y, center_x + text_w, center_y + text_h + + +LABEL_ANNOTATOR = LabelAnnotator(text_padding=4, + text_scale=0.5, + text_thickness=1) + + +def parse_args(): + parser = argparse.ArgumentParser(description='YOLO-World Demo') + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint', help='checkpoint file') + parser.add_argument( + '--work-dir', + help='the directory to save the file containing evaluation metrics', + default='output') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + args = parser.parse_args() + return args + + +def generate_image_embeddings(prompt_image, + vision_encoder, + vision_processor, + projector, + device='cuda:0'): + prompt_image = prompt_image.convert('RGB') + inputs = vision_processor(images=[prompt_image], + return_tensors="pt", + padding=True) + inputs = inputs.to(device) + image_outputs = vision_encoder(**inputs) + img_feats = image_outputs.image_embeds.view(1, -1) + img_feats = img_feats / img_feats.norm(p=2, dim=-1, keepdim=True) + if projector is not None: + img_feats = projector(img_feats) + return img_feats + + +def run_image(runner, + vision_encoder, + vision_processor, + padding_token, + image, + text, + prompt_image, + add_padding, + max_num_boxes, + score_thr, + nms_thr, + image_path='./work_dirs/demo.png'): + image = image.convert('RGB') + if prompt_image is not None: + texts = [['object'], [' ']] + projector = None + if hasattr(runner.model, 'image_prompt_encoder'): + projector = runner.model.image_prompt_encoder.projector + prompt_embeddings = generate_image_embeddings( + prompt_image, + vision_encoder=vision_encoder, + vision_processor=vision_processor, + projector=projector) + if add_padding == 'padding': + prompt_embeddings = torch.cat([prompt_embeddings, padding_token], + dim=0) + prompt_embeddings = prompt_embeddings / prompt_embeddings.norm( + p=2, dim=-1, keepdim=True) + runner.model.num_test_classes = prompt_embeddings.shape[0] + runner.model.setembeddings(prompt_embeddings[None]) + else: + runner.model.setembeddings(None) + texts = [[t.strip()] for t in text.split(',')] + data_info = dict(img_id=0, img=np.array(image), texts=texts) + data_info = runner.pipeline(data_info) + data_batch = dict(inputs=data_info['inputs'].unsqueeze(0), + data_samples=[data_info['data_samples']]) + + with autocast(enabled=False), torch.no_grad(): + if (prompt_image is not None) and ('texts' in data_batch['data_samples'][ + 0]): + del data_batch['data_samples'][0]['texts'] + output = runner.model.test_step(data_batch)[0] + pred_instances = output.pred_instances + + keep = nms(pred_instances.bboxes, + pred_instances.scores, + iou_threshold=nms_thr) + pred_instances = pred_instances[keep] + pred_instances = pred_instances[pred_instances.scores.float() > score_thr] + + if len(pred_instances.scores) > max_num_boxes: + indices = pred_instances.scores.float().topk(max_num_boxes)[1] + pred_instances = pred_instances[indices] + + pred_instances = pred_instances.cpu().numpy() + if 'masks' in pred_instances: + masks = pred_instances['masks'] + else: + masks = None + detections = sv.Detections(xyxy=pred_instances['bboxes'], + class_id=pred_instances['labels'], + confidence=pred_instances['scores'], + mask=masks) + labels = [ + f"{texts[class_id][0]} {confidence:0.2f}" for class_id, confidence in + zip(detections.class_id, detections.confidence) + ] + + image = np.array(image) + image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) # Convert RGB to BGR + image = BOUNDING_BOX_ANNOTATOR.annotate(image, detections) + image = LABEL_ANNOTATOR.annotate(image, detections, labels=labels) + if masks is not None: + image = MASK_ANNOTATOR.annotate(image, detections) + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # Convert BGR to RGB + image = Image.fromarray(image) + return image + + +def demo(runner, args, vision_encoder, vision_processor, padding_embed): + with gr.Blocks(title="YOLO-World") as demo: + with gr.Row(): + gr.Markdown('

YOLO-World: Real-Time Open-Vocabulary ' + 'Object Detector

') + with gr.Row(): + image = gr.Image(type='pil', label='input image') + output_image = gr.Image(type='pil', label='output image') + with gr.Row(): + with gr.Column(scale=0.3): + with gr.Row(): + prompt_image = gr.Image(type='pil', + label='Image Prompts', + height=300) + with gr.Row(): + add_padding = gr.Radio(["padding", "none"], + label="Padding Prompt", + info="whether add padding prompt") + with gr.Column(scale=0.3): + with gr.Row(): + input_text = gr.Textbox( + lines=7, + label='Text Prompts:\nEnter the classes to be detected, ' + 'separated by comma', + value=', '.join(CocoDataset.METAINFO['classes']), + elem_id='textbox') + with gr.Column(scale=0.4): + max_num_boxes = gr.Slider(minimum=1, + maximum=300, + value=100, + step=1, + interactive=True, + label='Maximum Number Boxes') + score_thr = gr.Slider(minimum=0, + maximum=1, + value=0.05, + step=0.001, + interactive=True, + label='Score Threshold') + nms_thr = gr.Slider(minimum=0, + maximum=1, + value=0.7, + step=0.001, + interactive=True, + label='NMS Threshold') + + with gr.Row(): + submit = gr.Button('Submit') + clear = gr.Button('Clear') + + exp_image_dir = "./gradio_examples/image_prompts/images/" + exp_prompt_dir = "./gradio_examples/image_prompts/prompts/" + example = gr.Examples( + examples=[ + [ + exp_image_dir + "0.jpeg", exp_prompt_dir + "0.png", "", + "none", 0.3, 0.5, 100 + ], + [ + exp_image_dir + "1.png", exp_prompt_dir + "1.png", "", + "padding", 0.2, 0.1, 100 + ], + [ + exp_image_dir + "2.png", exp_prompt_dir + "2.png", "", + "padding", 0.0, 0.1, 200 + ], + [ + exp_image_dir + "3.png", exp_prompt_dir + "3.png", "", + "padding", 0.3, 0.5, 100 + ], + [ + exp_image_dir + "4.png", exp_prompt_dir + "4.png", "", + "padding", 0.01, 0.1, 200 + ], + [ + exp_image_dir + "5.png", exp_prompt_dir + "5.png", "", + "none", 0.3, 0.5, 100 + ], + ], + inputs=[ + image, prompt_image, input_text, add_padding, score_thr, + nms_thr, max_num_boxes + ], + ) + + submit.click( + partial(run_image, runner, vision_encoder, vision_processor, + padding_embed), [ + image, + input_text, + prompt_image, + add_padding, + max_num_boxes, + score_thr, + nms_thr, + ], [output_image]) + clear.click(lambda: [None, None, '', None], None, + [image, prompt_image, input_text, output_image]) + + demo.launch(server_name='0.0.0.0', + server_port=38721) # port 80 does not work for me + + +if __name__ == '__main__': + args = parse_args() + + # load config + cfg = Config.fromfile(args.config) + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + if args.work_dir is not None: + cfg.work_dir = args.work_dir + elif cfg.get('work_dir', None) is None: + cfg.work_dir = osp.join('./work_dirs', + osp.splitext(osp.basename(args.config))[0]) + + cfg.load_from = args.checkpoint + + if 'runner_type' not in cfg: + runner = Runner.from_cfg(cfg) + else: + runner = RUNNERS.build(cfg) + + runner.call_hook('before_run') + runner.load_or_resume() + pipeline = cfg.test_dataloader.dataset.pipeline + pipeline[0].type = 'mmdet.LoadImageFromNDArray' + runner.pipeline = Compose(pipeline) + runner.model.eval() + + # init vision encoder + clip_model = "/group/40034/adriancheng/pretrained_models/open-ai-clip-vit-base-patch32" + vision_model = CLIPVisionModelWithProjection.from_pretrained(clip_model) + processor = AutoProcessor.from_pretrained(clip_model) + device = 'cuda:0' + vision_model.to(device) + + texts = [' '] + tokenizer = AutoTokenizer.from_pretrained(clip_model) + text_model = CLIPTextModelWithProjection.from_pretrained(clip_model) + # device = 'cuda:0' + text_model.to(device) + texts = tokenizer(text=texts, return_tensors='pt', padding=True) + texts = texts.to(device) + text_outputs = text_model(**texts) + txt_feats = text_outputs.text_embeds + txt_feats = txt_feats / txt_feats.norm(p=2, dim=-1, keepdim=True) + txt_feats = txt_feats.reshape(-1, txt_feats.shape[-1]) + txt_feats = txt_feats[0].unsqueeze(0) + demo(runner, args, vision_model, processor, txt_feats) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/inference.ipynb b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..19cc7b1480cc0b0e732762cc166cf52b568f17d2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/inference.ipynb @@ -0,0 +1,2836 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "PorcLK9OylD6" + }, + "source": [ + " ![yolo_logo.png](data:image/png;base64,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)\n", + "\n", + "\n", + " This YOLO-World notebook is a Inferencing notebook presenting Real-Time Open-Vocabulary Object Detection.\n", + "\n", + "We hope that the resources in this notebook will help you for inferencing." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zw1OxP87zjCM" + }, + "source": [ + "## Setup\n", + "\n", + "Clone GitHub [repository](https://github.com/AILab-CVC/YOLO-World) and install dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rlsGVhscqjY0", + "outputId": "382bd549-11ee-4e1b-ec00-5e1401911bf4" + }, + "outputs": [], + "source": [ + "!git clone --recursive https://github.com/AILab-CVC/YOLO-World\n", + "%cd YOLO-World/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uE1GmCSAJHXC", + "outputId": "43654a80-834a-4d34-caa6-00ae9a030f2e" + }, + "outputs": [], + "source": [ + "import os\n", + "# Install certain version of requests, tqdm, rich for openxlab (fix for yolo_world)\n", + "# Install mmcv before avoding compiling of mmcv and shortining waiting time installs \"whl\" file\n", + "# Downgrade pytorch version for fast installing mmcv (your on prem should finish faster with latest pytorch)\n", + "\n", + "\n", + "if 'COLAB_GPU' in os.environ:\n", + " !pip install torch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 --index-url https://download.pytorch.org/whl/cu121 -q\n", + " !pip install requests==2.28.2 tqdm==4.65.0 rich==13.4.2 -q\n", + " %pip install -U openmim -q\n", + " !mim install \"mmengine>=0.7.0\" -q\n", + " !mim install \"mmcv\" -q\n", + "else:\n", + " !pip install torch wheel requests==2.28.2 tqdm==4.65.0 rich==13.4.2 -q\n", + "\n", + "!pip install -e . -vv -q" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "v_Pgd1urgbj8" + }, + "outputs": [], + "source": [ + "if 'COLAB_GPU' in os.environ:\n", + " # Restart colab session (required for yolo_world to work in google colab)\n", + " quit()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZWq1gYXD2c4n" + }, + "source": [ + "## Pretrained Models\n", + "\n", + "Download Pretrained weights from Huggingface and set configuration" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LGuy6naerg4e", + "outputId": "c57e8147-c06c-4782-f5bf-6aa3e8ddeb58" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "%cd YOLO-World/\n", + "if not os.path.exists(\"pretrained_weights\"):\n", + " os.makedirs(\"pretrained_weights\")\n", + "\n", + "# Download pretrained weights of YOLO-Worldv2-L\tO365+GoldG img_size=1280 model\n", + "!wget -P pretrained_weights/ https://huggingface.co/wondervictor/YOLO-World/resolve/main/yolo_world_v2_l_obj365v1_goldg_pretrain_1280ft-9babe3f6.pth\n", + "!wget https://media.roboflow.com/notebooks/examples/dog.jpeg" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YECjGYE7-Ojg" + }, + "source": [ + "## Loading model configurations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "0bc8d02b9b0941f8b38f822b8552e54c", + "c5081cf89abc4514b81b0a705850b26f", + "93a7172913a84728a2919fe8796567c0", + "c50ae95e956d456395d05f12367ff8e3", + "c80456ab37c844b1beb074e74b17d8fb", + "4e47a4bc196e44dba1d7ce4faa5b74af", + "d0bad9ce27a742a49667d1cd58eea350", + "32f222c92f844a8ea780960c0e25a64c", + "06c1c81b5e8544d8aaca394f2e13539e", + "81df29145f4449339e75f78919147899", + "614d44b9730b4fe9a01305ac6c822388", + "1745520fa3834cbf900b1646fec5d6aa", + "768b536c12f84b1cb24d38675573baa2", + "569e8aabbcd74e4f9288bdebeb91400b", + "ad5431bc98784ee7adcf489989aba432", + "8614da2bade94ade978fe71994c777fa", + "6113de583b7a4a22bbbbfcf9a0ae6ea7", + "164ffff1e1944183b01d8cf76541556a", + "cd8f2fffa9a845cfbc2ce664647acda5", + "32b452668efa4b61acacd04d289edde0", + "e46b4e1e95da4d6f924a851265403480", + "ee06192a75fc403ba6d945da2efe4317", + "828a59ea87f34d4f8be9fa6fb63fe991", + "0becbcf3af914252b73937ffd789c533", + "8dc08812835f40e9a85c73ea57710029", + "bd6743fab19a4056a741fb923f1d66c6", + "cfc1570a53d4467397583e5614f35515", + "52d5fe0cd2514f87917ab8bcf923becf", + "0cee1b12a94c4fdaa97d7b0e57a9d8f6", + "ef7a3e2a70624fdfa2d590635e962ffd", + "794250f1a0b44831864f487cfe4be7b3", + "4b48981f033a4e0b89b3dc1cd088599e", + "46da2b5501cf471a99f354f17e85fc1d", + "084791b432c64ea383eeb10dd912d27f", + "c7e34cc6b3b54c36933cf4b21f32b469", + "961b3186964b4aa694ed50e601ca6ea6", + "9c7aebef36c94f659420f35c6951ac14", + "0381e7fdec3642d7af08a11841aaaba4", + "b69eb52454c64fb4bac7c9f008241d24", + "5dfaba276a3c480d837a75767300e96f", + "309c33ce179144ac9b23d6396f2fdcd6", + "dc6812fd13504f6bae35d81aaf2593fa", + "f7463653c82e41b087e794191e70c43e", + "7c53e4cff8344da8858060970b931a80", + "07cb92c22899453291baccd1f9b11a49", + "cbc909708fca4191a80767479a9c9c55", + "152972aaf5c7433da0a7ce4889694cf4", + "b769fadb878c43beaec040a779ba9067", + "483f26b6d2e54bb581e8a6392b8e1b39", + "b2dd4e48fb974451979e37fb99bbdf5b", + "53a11753fc664f12942c0a5a8f62e695", + "e908586e492443c6a28ed16750df6748", + "013ebfb59e88443d978bb2a4f3a68f96", + "265d430fcc604c6984d70b7e63f11e37", + "f55df7a2f0474b5ab6d0a23bcedf8cc2", + "8a23897839594ba4827c5a34463dbb35", + "ce8d0eadfac444a6b88e0ba16ab6f3f9", + "2d181d3861c64d0c9d71331751de111e", + "fd9cc05ff50e4463b004cacd050b59c3", + "dedf6f98735643d5bb53ff2e874137c7", + "5dbdd01ad0bd4939937fa32eb32182a1", + "fd7d351c2a5943cd9934b36be67481ca", + "f9ecf05660fa4512b4ff4cbb9d30f3e1", + "898c2d408c0a4b34851f7fbf537f45b1", + "d5797b57dcf04274a5f7077d104a62b6", + "ec8e16b5e78d4c55b100090ee7e23ddc", + "14b64b065ef740cbbff5587f062b04a3", + "5ede178010f54c259c9802698a599664", + "225ca87fffb54bfa9514513ace1fdbf1", + "cd906068e1cb46e4b5b62fc6267e8e6d", + "0aafe16d6e6d4561932cba3bed69f562", + "a81ab5c22fdc4ea99ebe396d3b43c552", + "8841ee0d44fe4073b3dc5237c8045185", + "d839228be8b84096a587489217630b7f", + "b76961c341d64959ae6ed7ad40f6abab", + "df073637968a4ca499a861f74869d45d", + "2f5098940d27496983565ddb3ab158bd" + ] + }, + "id": "tFQXnK-FsXlj", + "outputId": "6e6286aa-fbf8-44b1-94f6-2ccc661d040e" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "from mmengine.config import Config\n", + "from mmengine.dataset import Compose\n", + "from mmengine.runner import Runner\n", + "from mmengine.runner.amp import autocast\n", + "from mmyolo.registry import RUNNERS\n", + "from torchvision.ops import nms\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " # load config\n", + " cfg = Config.fromfile(\n", + " \"configs/pretrain/yolo_world_v2_l_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py\"\n", + " )\n", + " cfg.work_dir = \".\"\n", + " cfg.load_from = \"pretrained_weights/yolo_world_v2_l_obj365v1_goldg_pretrain_1280ft-9babe3f6.pth\"\n", + " runner = Runner.from_cfg(cfg)\n", + " runner.call_hook(\"before_run\")\n", + " runner.load_or_resume()\n", + " pipeline = cfg.test_dataloader.dataset.pipeline\n", + " runner.pipeline = Compose(pipeline)\n", + "\n", + " # run model evaluation\n", + " runner.model.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7syIir2qHoc9" + }, + "outputs": [], + "source": [ + "def colorstr(*input):\n", + " \"\"\"\n", + " Helper function for style logging\n", + " \"\"\"\n", + " *args, string = input if len(input) > 1 else (\"bold\", input[0])\n", + " colors = {\"bold\": \"\\033[1m\"}\n", + "\n", + " return \"\".join(colors[x] for x in args) + f\"{string}\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NI1DSw4SCCUU" + }, + "source": [ + "# Run Image Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "ozklQl6BnsLI" + }, + "outputs": [], + "source": [ + "import PIL.Image\n", + "import cv2\n", + "import supervision as sv\n", + "\n", + "bounding_box_annotator = sv.BoxAnnotator()\n", + "label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER)\n", + "mask_annotator = sv.MaskAnnotator()\n", + "\n", + "class_names = (\"person, bicycle, car, motorcycle, airplane, bus, train, truck, boat, \"\n", + " \"traffic light, fire hydrant, stop sign, parking meter, bench, bird, \"\n", + " \"cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe, \"\n", + " \"backpack, umbrella, handbag, tie, suitcase, frisbee, skis, snowboard, \"\n", + " \"sports ball, kite, baseball bat, baseball glove, skateboard, \"\n", + " \"surfboard, tennis racket, bottle, wine glass, cup, fork, knife, \"\n", + " \"spoon, bowl, banana, apple, sandwich, orange, broccoli, carrot, \"\n", + " \"hot dog, pizza, donut, cake, chair, couch, potted plant, bed, \"\n", + " \"dining table, toilet, tv, laptop, mouse, remote, keyboard, \"\n", + " \"cell phone, microwave, oven, toaster, sink, refrigerator, book, \"\n", + " \"clock, vase, scissors, teddy bear, hair drier, toothbrush\")\n", + "\n", + "class_names2 = (\"dog, eye, tongue, ear, leash\")\n", + "\n", + "\n", + "def run_image(\n", + " runner,\n", + " input_image,\n", + " max_num_boxes=100,\n", + " score_thr=0.05,\n", + " nms_thr=0.5,\n", + " output_image=\"output.png\",\n", + "):\n", + " output_image = \"runs/detect/\"+output_image\n", + " texts = [[t.strip()] for t in class_names.split(\",\")] + [[\" \"]]\n", + " data_info = runner.pipeline(dict(img_id=0, img_path=input_image,\n", + " texts=texts))\n", + "\n", + " data_batch = dict(\n", + " inputs=data_info[\"inputs\"].unsqueeze(0),\n", + " data_samples=[data_info[\"data_samples\"]],\n", + " )\n", + "\n", + " with autocast(enabled=False), torch.no_grad():\n", + " output = runner.model.test_step(data_batch)[0]\n", + " runner.model.class_names = texts\n", + " pred_instances = output.pred_instances\n", + "\n", + " # nms\n", + " keep_idxs = nms(pred_instances.bboxes, pred_instances.scores, iou_threshold=nms_thr)\n", + " pred_instances = pred_instances[keep_idxs]\n", + " pred_instances = pred_instances[pred_instances.scores.float() > score_thr]\n", + "\n", + " if len(pred_instances.scores) > max_num_boxes:\n", + " indices = pred_instances.scores.float().topk(max_num_boxes)[1]\n", + " pred_instances = pred_instances[indices]\n", + " output.pred_instances = pred_instances\n", + "\n", + " # predictions\n", + " pred_instances = pred_instances.cpu().numpy()\n", + "\n", + " if 'masks' in pred_instances:\n", + " masks = pred_instances['masks']\n", + " else:\n", + " masks = None\n", + " \n", + " detections = sv.Detections(\n", + " xyxy=pred_instances['bboxes'],\n", + " class_id=pred_instances['labels'],\n", + " confidence=pred_instances['scores']\n", + " )\n", + "\n", + " # label ids with confidence scores\n", + " labels = [\n", + " f\"{class_id} {confidence:0.2f}\"\n", + " for class_id, confidence\n", + " in zip(detections.class_id, detections.confidence)\n", + " ]\n", + "\n", + " # draw bounding box with label\n", + " image = PIL.Image.open(input_image)\n", + " svimage = np.array(image)\n", + " svimage = bounding_box_annotator.annotate(svimage, detections)\n", + " svimage = label_annotator.annotate(svimage, detections, labels)\n", + " if masks is not None:\n", + " svimage = mask_annotator.annotate(image, detections)\n", + "\n", + " # save output image\n", + " cv2.imwrite(output_image, svimage[:, :, ::-1])\n", + " print(f\"Results saved to {colorstr('bold', output_image)}\")\n", + "\n", + " return svimage[:, :, ::-1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 979 + }, + "id": "-BL_keU8moAM", + "outputId": "78fe2957-1980-49b7-a64d-6a5d9f62cacf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results saved to \u001b[1mruns/detect/output.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img = run_image(runner,\"dog.jpeg\")\n", + "sv.plot_image(img)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "013ebfb59e88443d978bb2a4f3a68f96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0381e7fdec3642d7af08a11841aaaba4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06c1c81b5e8544d8aaca394f2e13539e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "07cb92c22899453291baccd1f9b11a49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cbc909708fca4191a80767479a9c9c55", + "IPY_MODEL_152972aaf5c7433da0a7ce4889694cf4", + "IPY_MODEL_b769fadb878c43beaec040a779ba9067" + ], + "layout": "IPY_MODEL_483f26b6d2e54bb581e8a6392b8e1b39" + } + }, + "084791b432c64ea383eeb10dd912d27f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c7e34cc6b3b54c36933cf4b21f32b469", + "IPY_MODEL_961b3186964b4aa694ed50e601ca6ea6", + "IPY_MODEL_9c7aebef36c94f659420f35c6951ac14" + ], + "layout": "IPY_MODEL_0381e7fdec3642d7af08a11841aaaba4" + } + }, + "0aafe16d6e6d4561932cba3bed69f562": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bc8d02b9b0941f8b38f822b8552e54c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c5081cf89abc4514b81b0a705850b26f", + "IPY_MODEL_93a7172913a84728a2919fe8796567c0", + "IPY_MODEL_c50ae95e956d456395d05f12367ff8e3" + ], + "layout": "IPY_MODEL_c80456ab37c844b1beb074e74b17d8fb" + } + }, + "0becbcf3af914252b73937ffd789c533": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_52d5fe0cd2514f87917ab8bcf923becf", + "placeholder": "​", + "style": "IPY_MODEL_0cee1b12a94c4fdaa97d7b0e57a9d8f6", + "value": "vocab.json: 100%" + } + }, + "0cee1b12a94c4fdaa97d7b0e57a9d8f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "14b64b065ef740cbbff5587f062b04a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5ede178010f54c259c9802698a599664", + "IPY_MODEL_225ca87fffb54bfa9514513ace1fdbf1", + "IPY_MODEL_cd906068e1cb46e4b5b62fc6267e8e6d" + ], + "layout": "IPY_MODEL_0aafe16d6e6d4561932cba3bed69f562" + } + }, + "152972aaf5c7433da0a7ce4889694cf4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e908586e492443c6a28ed16750df6748", + "max": 2224041, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_013ebfb59e88443d978bb2a4f3a68f96", + "value": 2224041 + } + }, + "164ffff1e1944183b01d8cf76541556a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1745520fa3834cbf900b1646fec5d6aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_768b536c12f84b1cb24d38675573baa2", + "IPY_MODEL_569e8aabbcd74e4f9288bdebeb91400b", + "IPY_MODEL_ad5431bc98784ee7adcf489989aba432" + ], + "layout": "IPY_MODEL_8614da2bade94ade978fe71994c777fa" + } + }, + "225ca87fffb54bfa9514513ace1fdbf1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d839228be8b84096a587489217630b7f", + "max": 605247071, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b76961c341d64959ae6ed7ad40f6abab", + "value": 605247071 + } + }, + "265d430fcc604c6984d70b7e63f11e37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d181d3861c64d0c9d71331751de111e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f9ecf05660fa4512b4ff4cbb9d30f3e1", + "max": 389, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_898c2d408c0a4b34851f7fbf537f45b1", + "value": 389 + } + }, + "2f5098940d27496983565ddb3ab158bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "309c33ce179144ac9b23d6396f2fdcd6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "32b452668efa4b61acacd04d289edde0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "32f222c92f844a8ea780960c0e25a64c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "46da2b5501cf471a99f354f17e85fc1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "483f26b6d2e54bb581e8a6392b8e1b39": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4b48981f033a4e0b89b3dc1cd088599e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e47a4bc196e44dba1d7ce4faa5b74af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52d5fe0cd2514f87917ab8bcf923becf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53a11753fc664f12942c0a5a8f62e695": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "569e8aabbcd74e4f9288bdebeb91400b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd8f2fffa9a845cfbc2ce664647acda5", + "max": 4186, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_32b452668efa4b61acacd04d289edde0", + "value": 4186 + } + }, + "5dbdd01ad0bd4939937fa32eb32182a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5dfaba276a3c480d837a75767300e96f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5ede178010f54c259c9802698a599664": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a81ab5c22fdc4ea99ebe396d3b43c552", + "placeholder": "​", + "style": "IPY_MODEL_8841ee0d44fe4073b3dc5237c8045185", + "value": "pytorch_model.bin: 100%" + } + }, + "6113de583b7a4a22bbbbfcf9a0ae6ea7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "614d44b9730b4fe9a01305ac6c822388": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "768b536c12f84b1cb24d38675573baa2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6113de583b7a4a22bbbbfcf9a0ae6ea7", + "placeholder": "​", + "style": "IPY_MODEL_164ffff1e1944183b01d8cf76541556a", + "value": "config.json: 100%" + } + }, + "794250f1a0b44831864f487cfe4be7b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7c53e4cff8344da8858060970b931a80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "81df29145f4449339e75f78919147899": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "828a59ea87f34d4f8be9fa6fb63fe991": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0becbcf3af914252b73937ffd789c533", + "IPY_MODEL_8dc08812835f40e9a85c73ea57710029", + "IPY_MODEL_bd6743fab19a4056a741fb923f1d66c6" + ], + "layout": "IPY_MODEL_cfc1570a53d4467397583e5614f35515" + } + }, + "8614da2bade94ade978fe71994c777fa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8841ee0d44fe4073b3dc5237c8045185": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "898c2d408c0a4b34851f7fbf537f45b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8a23897839594ba4827c5a34463dbb35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ce8d0eadfac444a6b88e0ba16ab6f3f9", + "IPY_MODEL_2d181d3861c64d0c9d71331751de111e", + "IPY_MODEL_fd9cc05ff50e4463b004cacd050b59c3" + ], + "layout": "IPY_MODEL_dedf6f98735643d5bb53ff2e874137c7" + } + }, + "8dc08812835f40e9a85c73ea57710029": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef7a3e2a70624fdfa2d590635e962ffd", + "max": 862328, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_794250f1a0b44831864f487cfe4be7b3", + "value": 862328 + } + }, + "93a7172913a84728a2919fe8796567c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_32f222c92f844a8ea780960c0e25a64c", + "max": 568, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_06c1c81b5e8544d8aaca394f2e13539e", + "value": 568 + } + }, + "961b3186964b4aa694ed50e601ca6ea6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_309c33ce179144ac9b23d6396f2fdcd6", + "max": 524657, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dc6812fd13504f6bae35d81aaf2593fa", + "value": 524657 + } + }, + "9c7aebef36c94f659420f35c6951ac14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f7463653c82e41b087e794191e70c43e", + "placeholder": "​", + "style": "IPY_MODEL_7c53e4cff8344da8858060970b931a80", + "value": " 525k/525k [00:00<00:00, 28.1MB/s]" + } + }, + "a81ab5c22fdc4ea99ebe396d3b43c552": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad5431bc98784ee7adcf489989aba432": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e46b4e1e95da4d6f924a851265403480", + "placeholder": "​", + "style": "IPY_MODEL_ee06192a75fc403ba6d945da2efe4317", + "value": " 4.19k/4.19k [00:00<00:00, 161kB/s]" + } + }, + "b2dd4e48fb974451979e37fb99bbdf5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b69eb52454c64fb4bac7c9f008241d24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b76961c341d64959ae6ed7ad40f6abab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b769fadb878c43beaec040a779ba9067": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_265d430fcc604c6984d70b7e63f11e37", + "placeholder": "​", + "style": "IPY_MODEL_f55df7a2f0474b5ab6d0a23bcedf8cc2", + "value": " 2.22M/2.22M [00:00<00:00, 8.62MB/s]" + } + }, + "bd6743fab19a4056a741fb923f1d66c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b48981f033a4e0b89b3dc1cd088599e", + "placeholder": "​", + "style": "IPY_MODEL_46da2b5501cf471a99f354f17e85fc1d", + "value": " 862k/862k [00:00<00:00, 1.24MB/s]" + } + }, + "c5081cf89abc4514b81b0a705850b26f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4e47a4bc196e44dba1d7ce4faa5b74af", + "placeholder": "​", + "style": "IPY_MODEL_d0bad9ce27a742a49667d1cd58eea350", + "value": "tokenizer_config.json: 100%" + } + }, + "c50ae95e956d456395d05f12367ff8e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81df29145f4449339e75f78919147899", + "placeholder": "​", + "style": "IPY_MODEL_614d44b9730b4fe9a01305ac6c822388", + "value": " 568/568 [00:00<00:00, 24.3kB/s]" + } + }, + "c7e34cc6b3b54c36933cf4b21f32b469": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b69eb52454c64fb4bac7c9f008241d24", + "placeholder": "​", + "style": "IPY_MODEL_5dfaba276a3c480d837a75767300e96f", + "value": "merges.txt: 100%" + } + }, + "c80456ab37c844b1beb074e74b17d8fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cbc909708fca4191a80767479a9c9c55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b2dd4e48fb974451979e37fb99bbdf5b", + "placeholder": "​", + "style": "IPY_MODEL_53a11753fc664f12942c0a5a8f62e695", + "value": "tokenizer.json: 100%" + } + }, + "cd8f2fffa9a845cfbc2ce664647acda5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd906068e1cb46e4b5b62fc6267e8e6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df073637968a4ca499a861f74869d45d", + "placeholder": "​", + "style": "IPY_MODEL_2f5098940d27496983565ddb3ab158bd", + "value": " 605M/605M [00:02<00:00, 182MB/s]" + } + }, + "ce8d0eadfac444a6b88e0ba16ab6f3f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5dbdd01ad0bd4939937fa32eb32182a1", + "placeholder": "​", + "style": "IPY_MODEL_fd7d351c2a5943cd9934b36be67481ca", + "value": "special_tokens_map.json: 100%" + } + }, + "cfc1570a53d4467397583e5614f35515": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0bad9ce27a742a49667d1cd58eea350": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d5797b57dcf04274a5f7077d104a62b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d839228be8b84096a587489217630b7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc6812fd13504f6bae35d81aaf2593fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dedf6f98735643d5bb53ff2e874137c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "df073637968a4ca499a861f74869d45d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e46b4e1e95da4d6f924a851265403480": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e908586e492443c6a28ed16750df6748": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec8e16b5e78d4c55b100090ee7e23ddc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee06192a75fc403ba6d945da2efe4317": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ef7a3e2a70624fdfa2d590635e962ffd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f55df7a2f0474b5ab6d0a23bcedf8cc2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f7463653c82e41b087e794191e70c43e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9ecf05660fa4512b4ff4cbb9d30f3e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd7d351c2a5943cd9934b36be67481ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fd9cc05ff50e4463b004cacd050b59c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d5797b57dcf04274a5f7077d104a62b6", + "placeholder": "​", + "style": "IPY_MODEL_ec8e16b5e78d4c55b100090ee7e23ddc", + "value": " 389/389 [00:00<00:00, 31.4kB/s]" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/ball.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/ball.png new file mode 100644 index 0000000000000000000000000000000000000000..42f4ddfbb5578e5be835a59f0ac0d329879f250f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/ball.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c61d1e953279c66ed67292931fd7cc13b139ec45a8ef12d0f0323de67c46823d +size 437123 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/bus.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/bus.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2cf0dab1214b3c06668e2c6e3a1666463acfe88c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/bus.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33b198a1d2839bb9ac4c65d61f9e852196793cae9a0781360859425f6022b69c +size 487438 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/car.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/car.png new file mode 100644 index 0000000000000000000000000000000000000000..9b53438c851960140d1d3842fda940e833e3b7b9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/car.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:87388cad8f4ef191e2ed3b842859f2c0d35141b33c9d73b9574b3087535fa63b +size 799498 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/cat.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/cat.png new file mode 100644 index 0000000000000000000000000000000000000000..06f68db5bbf2b32fe720c63f3d1e57864b794f3d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/cat.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a84e462b0987d4b66d1bab3daa1d4d4d72135bee0683ab3a4392e4026a33e025 +size 1572050 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/cat2.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/cat2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..90a788311aa1db331ac8dcf08fad8ecf68016545 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/cat2.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e1ca3349e21697fcd35d92676e9baf6920f9335b8cc123df76f41fd86559e538 +size 119885 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/fox.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/fox.png new file mode 100644 index 0000000000000000000000000000000000000000..95fa0f652c00f587048513781771e3a7c98358d4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/fox.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e072fa72982da659050dd5021688c70b085eb4fdf738c1bc7ec243c566291617 +size 783574 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/fox2.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/fox2.png new file mode 100644 index 0000000000000000000000000000000000000000..7923a272194e5bfbe982a8b550363de9574e6872 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/fox2.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ca4ff28cbd27473c789718d815b43f5521b7b2fbaaedc3ad912f281ae0ea5eb +size 1427897 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/human.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/human.png new file mode 100644 index 0000000000000000000000000000000000000000..8e1ee4c2f292747208219ba809bcb2a55ae2a6dc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/human.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c78016d4e35d086bcf02e747cf8c3dc416fe00e54b1447bdb972daf108dda796 +size 416241 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/sheep2.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/sheep2.png new file mode 100644 index 0000000000000000000000000000000000000000..c20c764b82181b3b0863ceea7a2013dc0fbc77f1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/sheep2.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a463fbc47a65dbda3e744c41c5a6926f1808ec3604429ed3874a81789a2c354b +size 587679 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/steel.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/steel.png new file mode 100644 index 0000000000000000000000000000000000000000..da72445e354f3852270a177fde68ace513f44e13 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/steel.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d6220acdc4c7620d7942a4e8f2063db423b5f0ff6720172eda22515c0f04d38 +size 604298 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/temp.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/temp.png new file mode 100644 index 0000000000000000000000000000000000000000..ad96597090aa4c3154ce8f715790e3ccc6ee324f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/temp.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a1d7b9fb37a383cf596d4031cd05681f7bdc75540e14f0b32c9ba8a69d978c3 +size 1425920 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/tiger.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/tiger.png new file mode 100644 index 0000000000000000000000000000000000000000..6f0f1a93dfa11279b798e9b6d319224dacc602a6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/tiger.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33cf42ad02f3df46696e8d293bf59dbf7ca728e04bf7b71dbdf18f843d56e051 +size 1316282 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/zidane.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/zidane.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6d86f9edfce6353b027f16b9df7a973c72e598ba --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/sample_images/zidane.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:356dad2107bb0254e4e4a81bc1d9c7140043e88569d546e5b404b19bffa77d0a +size 168949 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/simple_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/simple_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..fb797835db5be63d50cc5e213662d0039ae73cc4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/demo/simple_demo.py @@ -0,0 +1,61 @@ +# Copyright (c) Tencent Inc. All rights reserved. +import os.path as osp + +import cv2 +import torch +from mmengine.config import Config +from mmengine.dataset import Compose +from mmdet.apis import init_detector +from mmdet.utils import get_test_pipeline_cfg + + +def inference(model, image, texts, test_pipeline, score_thr=0.3, max_dets=100): + image = cv2.imread(image) + image = image[:, :, [2, 1, 0]] + data_info = dict(img=image, img_id=0, texts=texts) + data_info = test_pipeline(data_info) + data_batch = dict(inputs=data_info['inputs'].unsqueeze(0), + data_samples=[data_info['data_samples']]) + with torch.no_grad(): + output = model.test_step(data_batch)[0] + pred_instances = output.pred_instances + # score thresholding + pred_instances = pred_instances[pred_instances.scores.float() > score_thr] + # max detections + if len(pred_instances.scores) > max_dets: + indices = pred_instances.scores.float().topk(max_dets)[1] + pred_instances = pred_instances[indices] + + pred_instances = pred_instances.cpu().numpy() + boxes = pred_instances['bboxes'] + labels = pred_instances['labels'] + scores = pred_instances['scores'] + label_texts = [texts[x][0] for x in labels] + return boxes, labels, label_texts, scores + + +if __name__ == "__main__": + + config_file = "configs/pretrain/yolo_world_v2_x_vlpan_bn_2e-3_100e_4x8gpus_obj365v1_goldg_train_1280ft_lvis_minival.py" + checkpoint = "weights/yolo_world_v2_x_obj365v1_goldg_cc3mlite_pretrain_1280ft-14996a36.pth" + + cfg = Config.fromfile(config_file) + cfg.work_dir = osp.join('./work_dirs') + # init model + cfg.load_from = checkpoint + model = init_detector(cfg, checkpoint=checkpoint, device='cuda:0') + test_pipeline_cfg = get_test_pipeline_cfg(cfg=cfg) + test_pipeline_cfg[0].type = 'mmdet.LoadImageFromNDArray' + test_pipeline = Compose(test_pipeline_cfg) + + texts = [['person'], ['bus'], [' ']] + image = "demo/sample_images/bus.jpg" + print(f"starting to detect: {image}") + results = inference(model, image, texts, test_pipeline) + format_str = [ + f"obj-{idx}: {box}, label-{lbl}, class-{lbl_text}, score-{score}" + for idx, (box, lbl, lbl_text, score) in enumerate(zip(*results)) + ] + print("detecting results:") + for q in format_str: + print(q) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1816e7ed96ee34209c56af4a22eda5f1eb7e499b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/README.md @@ -0,0 +1,11 @@ +# MMYOLO Model Easy-Deployment + +## Introduction + +This project is developed for easily converting your MMYOLO models to other inference backends without the need of MMDeploy, which reduces the cost of both time and effort on getting familiar with MMDeploy. + +Currently we support converting to `ONNX` and `TensorRT` formats, other inference backends such `ncnn` will be added to this project as well. + +## Supported Backends + +- [Model Convert](docs/model_convert.md) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/README_zh-CN.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/README_zh-CN.md new file mode 100644 index 0000000000000000000000000000000000000000..4c6bc0cf4ef91edeced04bdf15af08ae1f6f0dcd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/README_zh-CN.md @@ -0,0 +1,11 @@ +# MMYOLO 模型转换 + +## 介绍 + +本项目作为 MMYOLO 的部署 project 单独存在，意图剥离 MMDeploy 当前的体系，独自支持用户完成模型训练后的转换和部署功能，使用户的学习和工程成本下降。 + +当前支持对 ONNX 格式和 TensorRT 格式的转换，后续对其他推理平台也会支持起来。 + +## 转换教程 + +- [Model Convert](docs/model_convert.md) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dc167f8515c66a30d884ed9655a11d45e21481c0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/__init__.py @@ -0,0 +1,5 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from .common import DeployC2f +from .focus import DeployFocus, GConvFocus, NcnnFocus + +__all__ = ['DeployFocus', 'NcnnFocus', 'GConvFocus', 'DeployC2f'] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/common.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/common.py new file mode 100644 index 0000000000000000000000000000000000000000..617875bd979a5b9150e476544090777118087a0b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/common.py @@ -0,0 +1,16 @@ +import torch +import torch.nn as nn +from torch import Tensor + + +class DeployC2f(nn.Module): + + def __init__(self, *args, **kwargs): + super().__init__() + + def forward(self, x: Tensor) -> Tensor: + x_main = self.main_conv(x) + x_main = [x_main, x_main[:, self.mid_channels:, ...]] + x_main.extend(blocks(x_main[-1]) for blocks in self.blocks) + x_main.pop(1) + return self.final_conv(torch.cat(x_main, 1)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/focus.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/focus.py new file mode 100644 index 0000000000000000000000000000000000000000..2a19afcca1d9c4e27109daeebd83907cd9b7b284 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/backbone/focus.py @@ -0,0 +1,79 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch import Tensor + + +class DeployFocus(nn.Module): + + def __init__(self, orin_Focus: nn.Module): + super().__init__() + self.__dict__.update(orin_Focus.__dict__) + + def forward(self, x: Tensor) -> Tensor: + batch_size, channel, height, width = x.shape + x = x.reshape(batch_size, channel, -1, 2, width) + x = x.reshape(batch_size, channel, x.shape[2], 2, -1, 2) + half_h = x.shape[2] + half_w = x.shape[4] + x = x.permute(0, 5, 3, 1, 2, 4) + x = x.reshape(batch_size, channel * 4, half_h, half_w) + + return self.conv(x) + + +class NcnnFocus(nn.Module): + + def __init__(self, orin_Focus: nn.Module): + super().__init__() + self.__dict__.update(orin_Focus.__dict__) + + def forward(self, x: Tensor) -> Tensor: + batch_size, c, h, w = x.shape + assert h % 2 == 0 and w % 2 == 0, f'focus for yolox needs even feature\ + height and width, got {(h, w)}.' + + x = x.reshape(batch_size, c * h, 1, w) + _b, _c, _h, _w = x.shape + g = _c // 2 + # fuse to ncnn's shufflechannel + x = x.view(_b, g, 2, _h, _w) + x = torch.transpose(x, 1, 2).contiguous() + x = x.view(_b, -1, _h, _w) + + x = x.reshape(_b, c * h * w, 1, 1) + + _b, _c, _h, _w = x.shape + g = _c // 2 + # fuse to ncnn's shufflechannel + x = x.view(_b, g, 2, _h, _w) + x = torch.transpose(x, 1, 2).contiguous() + x = x.view(_b, -1, _h, _w) + + x = x.reshape(_b, c * 4, h // 2, w // 2) + + return self.conv(x) + + +class GConvFocus(nn.Module): + + def __init__(self, orin_Focus: nn.Module): + super().__init__() + device = next(orin_Focus.parameters()).device + self.weight1 = torch.tensor([[1., 0], [0, 0]]).expand(3, 1, 2, + 2).to(device) + self.weight2 = torch.tensor([[0, 0], [1., 0]]).expand(3, 1, 2, + 2).to(device) + self.weight3 = torch.tensor([[0, 1.], [0, 0]]).expand(3, 1, 2, + 2).to(device) + self.weight4 = torch.tensor([[0, 0], [0, 1.]]).expand(3, 1, 2, + 2).to(device) + self.__dict__.update(orin_Focus.__dict__) + + def forward(self, x: Tensor) -> Tensor: + conv1 = F.conv2d(x, self.weight1, stride=2, groups=3) + conv2 = F.conv2d(x, self.weight2, stride=2, groups=3) + conv3 = F.conv2d(x, self.weight3, stride=2, groups=3) + conv4 = F.conv2d(x, self.weight4, stride=2, groups=3) + return self.conv(torch.cat([conv1, conv2, conv3, conv4], dim=1)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/bbox_code/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/bbox_code/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b85a815536a5749a15f0ad6aab2b028eb6a3fe0a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/bbox_code/__init__.py @@ -0,0 +1,5 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from .bbox_coder import (rtmdet_bbox_decoder, yolov5_bbox_decoder, + yolox_bbox_decoder) + +__all__ = ['yolov5_bbox_decoder', 'rtmdet_bbox_decoder', 'yolox_bbox_decoder'] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/bbox_code/bbox_coder.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/bbox_code/bbox_coder.py new file mode 100644 index 0000000000000000000000000000000000000000..6483cf8b0328aff3d61f1fa0788337ab536d347d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/bbox_code/bbox_coder.py @@ -0,0 +1,46 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from typing import Optional + +import torch +from torch import Tensor + + +def yolov5_bbox_decoder(priors: Tensor, bbox_preds: Tensor, + stride: Tensor) -> Tensor: + bbox_preds = bbox_preds.sigmoid() + + x_center = (priors[..., 0] + priors[..., 2]) * 0.5 + y_center = (priors[..., 1] + priors[..., 3]) * 0.5 + w = priors[..., 2] - priors[..., 0] + h = priors[..., 3] - priors[..., 1] + + x_center_pred = (bbox_preds[..., 0] - 0.5) * 2 * stride + x_center + y_center_pred = (bbox_preds[..., 1] - 0.5) * 2 * stride + y_center + w_pred = (bbox_preds[..., 2] * 2)**2 * w + h_pred = (bbox_preds[..., 3] * 2)**2 * h + + decoded_bboxes = torch.stack( + [x_center_pred, y_center_pred, w_pred, h_pred], dim=-1) + + return decoded_bboxes + + +def rtmdet_bbox_decoder(priors: Tensor, bbox_preds: Tensor, + stride: Optional[Tensor]) -> Tensor: + stride = stride[None, :, None] + bbox_preds *= stride + tl_x = (priors[..., 0] - bbox_preds[..., 0]) + tl_y = (priors[..., 1] - bbox_preds[..., 1]) + br_x = (priors[..., 0] + bbox_preds[..., 2]) + br_y = (priors[..., 1] + bbox_preds[..., 3]) + decoded_bboxes = torch.stack([tl_x, tl_y, br_x, br_y], -1) + return decoded_bboxes + + +def yolox_bbox_decoder(priors: Tensor, bbox_preds: Tensor, + stride: Optional[Tensor]) -> Tensor: + stride = stride[None, :, None] + xys = (bbox_preds[..., :2] * stride) + priors + whs = bbox_preds[..., 2:].exp() * stride + decoded_bboxes = torch.cat([xys, whs], -1) + return decoded_bboxes diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/CMakeLists.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..f640bea13bacfc0f6cc2f33e598f65cf5ce0922e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_minimum_required(VERSION 2.8.12) + +set(CMAKE_CUDA_ARCHITECTURES 60 61 62 70 72 75 86) +set(CMAKE_CUDA_COMPILER /usr/local/cuda/bin/nvcc) + +project(nvdsparsebbox_mmyolo LANGUAGES CXX) + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -O3 -g -Wall -Werror -shared -fPIC") +set(CMAKE_CXX_STANDARD 14) +set(CMAKE_BUILD_TYPE Release) +option(CUDA_USE_STATIC_CUDA_RUNTIME OFF) + +# CUDA +find_package(CUDA REQUIRED) + +# TensorRT +set(TensorRT_INCLUDE_DIRS "/usr/include/x86_64-linux-gnu" CACHE STRING "TensorRT headers path") +set(TensorRT_LIBRARIES "/usr/lib/x86_64-linux-gnu" CACHE STRING "TensorRT libs path") + +# DeepStream +set(DEEPSTREAM "/opt/nvidia/deepstream/deepstream" CACHE STRING "DeepStream root path") +set(DS_LIBRARIES ${DEEPSTREAM}/lib) +set(DS_INCLUDE_DIRS ${DEEPSTREAM}/sources/includes) + +include_directories( + ${CUDA_INCLUDE_DIRS} + ${TensorRT_INCLUDE_DIRS} + ${DS_INCLUDE_DIRS}) + +add_library( + ${PROJECT_NAME} + SHARED + custom_mmyolo_bbox_parser/nvdsparsebbox_mmyolo.cpp) + +target_link_libraries(${PROJECT_NAME} PRIVATE nvinfer nvinfer_plugin) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/README.md new file mode 100644 index 0000000000000000000000000000000000000000..111f3765e41d558b64097d8a25585bd9c14acf4f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/README.md @@ -0,0 +1,48 @@ +# Inference MMYOLO Models with DeepStream + +This project demonstrates how to inference MMYOLO models with customized parsers in [DeepStream SDK](https://developer.nvidia.com/deepstream-sdk). + +## Pre-requisites + +### 1. Install Nvidia Driver and CUDA + +First, please follow the official documents and instructions to install dedicated Nvidia graphic driver and CUDA matched to your gpu and target Nvidia AIoT devices. + +### 2. Install DeepStream SDK + +Second, please follow the official instruction to download and install DeepStream SDK. Currently stable version of DeepStream is v6.2. + +### 3. Generate TensorRT Engine + +As DeepStream builds on top of several NVIDIA libraries, you need to first convert your trained MMYOLO models to TensorRT engine files. We strongly recommend you to try the supported TensorRT deployment solution in [EasyDeploy](../../easydeploy/). + +## Build and Run + +Please make sure that your converted TensorRT engine is already located in the `deepstream` folder as the config shows. Create your own model config files and change the `config-file` parameter in [deepstream_app_config.txt](deepstream_app_config.txt) to the model you want to run with. + +```bash +mkdir build && cd build +cmake .. +make -j$(nproc) && make install +``` + +Then you can run the inference with this command. + +```bash +deepstream-app -c deepstream_app_config.txt +``` + +## Code Structure + +```bash +├── deepstream +│ ├── configs # config file for MMYOLO models +│ │ └── config_infer_rtmdet.txt +│ ├── custom_mmyolo_bbox_parser # customized parser for MMYOLO models to DeepStream formats +│ │ └── nvdsparsebbox_mmyolo.cpp +| ├── CMakeLists.txt +│ ├── coco_labels.txt # labels for coco detection +│ ├── deepstream_app_config.txt # deepStream reference app configs for MMYOLO models +│ ├── README_zh-CN.md +│ └── README.md +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/README_zh-CN.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/README_zh-CN.md new file mode 100644 index 0000000000000000000000000000000000000000..13a85d5bc90159c3ff9f1a32e93d01e82ed2faa4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/README_zh-CN.md @@ -0,0 +1,48 @@ +# 使用 DeepStream SDK 推理 MMYOLO 模型 + +本项目演示了如何使用 [DeepStream SDK](https://developer.nvidia.com/deepstream-sdk) 配合改写的 parser 来推理 MMYOLO 的模型。 + +## 预先准备 + +### 1. 安装 Nidia 驱动和 CUDA + +首先请根据当前的显卡驱动和目标使用设备的驱动完成显卡驱动和 CUDA 的安装。 + +### 2. 安装 DeepStream SDK + +目前 DeepStream SDK 稳定版本已经更新到 v6.2，官方推荐使用这个版本。 + +### 3. 将 MMYOLO 模型转换为 TensorRT Engine + +推荐使用 EasyDeploy 中的 TensorRT 方案完成目标模型的转换部署，具体可参考 [此文档](../../easydeploy/docs/model_convert.md) 。 + +## 编译使用 + +当前项目使用的是 MMYOLO 的 rtmdet 模型，若想使用其他的模型，请参照目录下的配置文件进行改写。然后将转换完的 TensorRT engine 放在当前目录下并执行如下命令： + +```bash +mkdir build && cd build +cmake .. +make -j$(nproc) && make install +``` + +完成编译后可使用如下命令进行推理： + +```bash +deepstream-app -c deepstream_app_config.txt +``` + +## 项目代码结构 + +```bash +├── deepstream +│ ├── configs # MMYOLO 模型对应的 DeepStream 配置 +│ │ └── config_infer_rtmdet.txt +│ ├── custom_mmyolo_bbox_parser # 适配 DeepStream formats 的 parser +│ │ └── nvdsparsebbox_mmyolo.cpp +| ├── CMakeLists.txt +│ ├── coco_labels.txt # coco labels +│ ├── deepstream_app_config.txt # DeepStream app 配置 +│ ├── README_zh-CN.md +│ └── README.md +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/coco_labels.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/coco_labels.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca76c80b5b2cd0b25047f75736656cfebc9da7aa --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/coco_labels.txt @@ -0,0 +1,80 @@ +person +bicycle +car +motorbike +aeroplane +bus +train +truck +boat +traffic light +fire hydrant +stop sign +parking meter +bench +bird +cat +dog +horse +sheep +cow +elephant +bear +zebra +giraffe +backpack +umbrella +handbag +tie +suitcase +frisbee +skis +snowboard +sports ball +kite +baseball bat +baseball glove +skateboard +surfboard +tennis racket +bottle +wine glass +cup +fork +knife +spoon +bowl +banana +apple +sandwich +orange +broccoli +carrot +hot dog +pizza +donut +cake +chair +sofa +pottedplant +bed +diningtable +toilet +tvmonitor +laptop +mouse +remote +keyboard +cell phone +microwave +oven +toaster +sink +refrigerator +book +clock +vase +scissors +teddy bear +hair drier +toothbrush diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_rtmdet.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_rtmdet.txt new file mode 100644 index 0000000000000000000000000000000000000000..a1e5efd2a3810730144e037ee96dfbd36124b0e6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_rtmdet.txt @@ -0,0 +1,22 @@ +[property] +gpu-id=0 +net-scale-factor=0.01735207357279195 +offsets=57.375;57.12;58.395 +model-color-format=1 +model-engine-file=../end2end.engine +labelfile-path=../coco_labels.txt +batch-size=1 +network-mode=0 +num-detected-classes=80 +interval=0 +gie-unique-id=1 +process-mode=1 +network-type=0 +cluster-mode=2 +maintain-aspect-ratio=1 +parse-bbox-func-name=NvDsInferParseCustomMMYOLO +custom-lib-path=../build/libnvdsparsebbox_mmyolo.so + +[class-attrs-all] +pre-cluster-threshold=0.45 +topk=100 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_yolov5.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_yolov5.txt new file mode 100644 index 0000000000000000000000000000000000000000..6ad7d6429cacd0a6050821e5b2a41317478f5119 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_yolov5.txt @@ -0,0 +1,21 @@ +[property] +gpu-id=0 +net-scale-factor=0.0039215697906911373 +model-color-format=0 +model-engine-file=../end2end.engine +labelfile-path=../coco_labels.txt +batch-size=1 +network-mode=0 +num-detected-classes=80 +interval=0 +gie-unique-id=1 +process-mode=1 +network-type=0 +cluster-mode=2 +maintain-aspect-ratio=1 +parse-bbox-func-name=NvDsInferParseCustomMMYOLO +custom-lib-path=../build/libnvdsparsebbox_mmyolo.so + +[class-attrs-all] +pre-cluster-threshold=0.45 +topk=100 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_yolov8.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_yolov8.txt new file mode 100644 index 0000000000000000000000000000000000000000..6ad7d6429cacd0a6050821e5b2a41317478f5119 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/configs/config_infer_yolov8.txt @@ -0,0 +1,21 @@ +[property] +gpu-id=0 +net-scale-factor=0.0039215697906911373 +model-color-format=0 +model-engine-file=../end2end.engine +labelfile-path=../coco_labels.txt +batch-size=1 +network-mode=0 +num-detected-classes=80 +interval=0 +gie-unique-id=1 +process-mode=1 +network-type=0 +cluster-mode=2 +maintain-aspect-ratio=1 +parse-bbox-func-name=NvDsInferParseCustomMMYOLO +custom-lib-path=../build/libnvdsparsebbox_mmyolo.so + +[class-attrs-all] +pre-cluster-threshold=0.45 +topk=100 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/custom_mmyolo_bbox_parser/nvdsparsebbox_mmyolo.cpp b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/custom_mmyolo_bbox_parser/nvdsparsebbox_mmyolo.cpp new file mode 100644 index 0000000000000000000000000000000000000000..eb780856cbd2b289cdf9dc8518438f946a2ab548 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/custom_mmyolo_bbox_parser/nvdsparsebbox_mmyolo.cpp @@ -0,0 +1,118 @@ +#include "nvdsinfer_custom_impl.h" +#include +#include + +/** + * Function expected by DeepStream for decoding the MMYOLO output. + * + * C-linkage [extern "C"] was written to prevent name-mangling. This function must return true after + * adding all bounding boxes to the objectList vector. + * + * @param [outputLayersInfo] std::vector of NvDsInferLayerInfo objects with information about the output layer. + * @param [networkInfo] NvDsInferNetworkInfo object with information about the MMYOLO network. + * @param [detectionParams] NvDsInferParseDetectionParams with information about some config params. + * @param [objectList] std::vector of NvDsInferParseObjectInfo objects to which bounding box information must + * be stored. + * + * @return true + */ + +// This is just the function prototype. The definition is written at the end of the file. +extern "C" bool NvDsInferParseCustomMMYOLO( + std::vector const& outputLayersInfo, + NvDsInferNetworkInfo const& networkInfo, + NvDsInferParseDetectionParams const& detectionParams, + std::vector& objectList); + +static __inline__ float clamp(float& val, float min, float max) +{ + return val > min ? (val < max ? val : max) : min; +} + +static std::vector decodeMMYoloTensor( + const int* num_dets, + const float* bboxes, + const float* scores, + const int* labels, + const float& conf_thres, + const unsigned int& img_w, + const unsigned int& img_h +) +{ + std::vector bboxInfo; + size_t nums = num_dets[0]; + for (size_t i = 0; i < nums; i++) + { + float score = scores[i]; + if (score < conf_thres)continue; + float x0 = (bboxes[i * 4]); + float y0 = (bboxes[i * 4 + 1]); + float x1 = (bboxes[i * 4 + 2]); + float y1 = (bboxes[i * 4 + 3]); + x0 = clamp(x0, 0.f, img_w); + y0 = clamp(y0, 0.f, img_h); + x1 = clamp(x1, 0.f, img_w); + y1 = clamp(y1, 0.f, img_h); + NvDsInferParseObjectInfo obj; + obj.left = x0; + obj.top = y0; + obj.width = x1 - x0; + obj.height = y1 - y0; + obj.detectionConfidence = score; + obj.classId = labels[i]; + bboxInfo.push_back(obj); + } + + return bboxInfo; +} + +/* C-linkage to prevent name-mangling */ +extern "C" bool NvDsInferParseCustomMMYOLO( + std::vector const& outputLayersInfo, + NvDsInferNetworkInfo const& networkInfo, + NvDsInferParseDetectionParams const& detectionParams, + std::vector& objectList) +{ + +// Some assertions and error checking. + if (outputLayersInfo.empty() || outputLayersInfo.size() != 4) + { + std::cerr << "Could not find output layer in bbox parsing" << std::endl; + return false; + } + +// Score threshold of bboxes. + const float conf_thres = detectionParams.perClassThreshold[0]; + +// Obtaining the output layer. + const NvDsInferLayerInfo& num_dets = outputLayersInfo[0]; + const NvDsInferLayerInfo& bboxes = outputLayersInfo[1]; + const NvDsInferLayerInfo& scores = outputLayersInfo[2]; + const NvDsInferLayerInfo& labels = outputLayersInfo[3]; + +// num_dets(int) bboxes(float) scores(float) labels(int) + assert (num_dets.dims.numDims == 2); + assert (bboxes.dims.numDims == 3); + assert (scores.dims.numDims == 2); + assert (labels.dims.numDims == 2); + + +// Decoding the output tensor of MMYOLO to the NvDsInferParseObjectInfo format. + std::vector objects = + decodeMMYoloTensor( + (const int*)(num_dets.buffer), + (const float*)(bboxes.buffer), + (const float*)(scores.buffer), + (const int*)(labels.buffer), + conf_thres, + networkInfo.width, + networkInfo.height + ); + + objectList.clear(); + objectList = objects; + return true; +} + +/* Check that the custom function has been defined correctly */ +CHECK_CUSTOM_PARSE_FUNC_PROTOTYPE(NvDsInferParseCustomMMYOLO); diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/deepstream_app_config.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/deepstream_app_config.txt new file mode 100644 index 0000000000000000000000000000000000000000..331776897a5e9109b9007ed1b7974f128287c4fc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/deepstream/deepstream_app_config.txt @@ -0,0 +1,62 @@ +[application] +enable-perf-measurement=1 +perf-measurement-interval-sec=5 + +[tiled-display] +enable=1 +rows=1 +columns=1 +width=1280 +height=720 +gpu-id=0 +nvbuf-memory-type=0 + +[source0] +enable=1 +type=3 +uri=file:///opt/nvidia/deepstream/deepstream/samples/streams/sample_1080p_h264.mp4 +num-sources=1 +gpu-id=0 +cudadec-memtype=0 + +[sink0] +enable=1 +type=2 +sync=0 +gpu-id=0 +nvbuf-memory-type=0 + +[osd] +enable=1 +gpu-id=0 +border-width=5 +text-size=15 +text-color=1;1;1;1; +text-bg-color=0.3;0.3;0.3;1 +font=Serif +show-clock=0 +clock-x-offset=800 +clock-y-offset=820 +clock-text-size=12 +clock-color=1;0;0;0 +nvbuf-memory-type=0 + +[streammux] +gpu-id=0 +live-source=0 +batch-size=1 +batched-push-timeout=40000 +width=1920 +height=1080 +enable-padding=0 +nvbuf-memory-type=0 + +[primary-gie] +enable=1 +gpu-id=0 +gie-unique-id=1 +nvbuf-memory-type=0 +config-file=configs/config_infer_rtmdet.txt + +[tests] +file-loop=0 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/docs/model_convert.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/docs/model_convert.md new file mode 100644 index 0000000000000000000000000000000000000000..9af62599dd1b56648680fc315ca88c35c7b31cb9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/docs/model_convert.md @@ -0,0 +1,156 @@ +# MMYOLO 模型 ONNX 转换 + +## 1. 导出后端支持的 ONNX + +## 环境依赖 + +- [onnx](https://github.com/onnx/onnx) + + ```shell + pip install onnx + ``` + + [onnx-simplifier](https://github.com/daquexian/onnx-simplifier) (可选，用于简化模型) + + ```shell + pip install onnx-simplifier + ``` + +\*\*\* 请确保您在 `MMYOLO` 根目录下运行相关脚本，避免无法找到相关依赖包。\*\*\* + +## 使用方法 + +[模型导出脚本](./projects/easydeploy/tools/export_onnx.py)用于将 `MMYOLO` 模型转换为 `onnx` 。 + +### 参数介绍: + +- `config` : 构建模型使用的配置文件，如 [`yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py`](./configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py) 。 +- `checkpoint` : 训练得到的权重文件，如 `yolov5s.pth` 。 +- `--work-dir` : 转换后的模型保存路径。 +- `--img-size`: 转换模型时输入的尺寸，如 `640 640`。 +- `--batch-size`: 转换后的模型输入 `batch size` 。 +- `--device`: 转换模型使用的设备，默认为 `cuda:0`。 +- `--simplify`: 是否简化导出的 `onnx` 模型，需要安装 [onnx-simplifier](https://github.com/daquexian/onnx-simplifier)，默认关闭。 +- `--opset`: 指定导出 `onnx` 的 `opset`，默认为 `11` 。 +- `--backend`: 指定导出 `onnx` 用于的后端名称，`ONNXRuntime`: `onnxruntime`, `TensorRT8`: `tensorrt8`, `TensorRT7`: `tensorrt7`，默认为`onnxruntime`即 `ONNXRuntime`。 +- `--pre-topk`: 指定导出 `onnx` 的后处理筛选候选框个数阈值，默认为 `1000`。 +- `--keep-topk`: 指定导出 `onnx` 的非极大值抑制输出的候选框个数阈值，默认为 `100`。 +- `--iou-threshold`: 非极大值抑制中过滤重复候选框的 `iou` 阈值，默认为 `0.65`。 +- `--score-threshold`: 非极大值抑制中过滤候选框得分的阈值，默认为 `0.25`。 +- `--model-only`: 指定仅导出模型 backbone + neck, 不包含后处理，默认关闭。 + +例子: + +```shell +python ./projects/easydeploy/tools/export.py \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5s.pth \ + --work-dir work_dir \ + --img-size 640 640 \ + --batch 1 \ + --device cpu \ + --simplify \ + --opset 11 \ + --backend 1 \ + --pre-topk 1000 \ + --keep-topk 100 \ + --iou-threshold 0.65 \ + --score-threshold 0.25 +``` + +然后利用后端支持的工具如 `TensorRT` 读取 `onnx` 再次转换为后端支持的模型格式如 `.engine/.plan` 等。 + +`MMYOLO` 目前支持 `TensorRT8`, `TensorRT7`, `ONNXRuntime` 后端的端到端模型转换，目前仅支持静态 shape 模型的导出和转换，动态 batch 或动态长宽的模型端到端转换会在未来继续支持。 + +端到端转换得到的 `onnx` 模型输入输出如图： + +
+ +
+ +输入名: `images`, 尺寸 640x640 + +输出名: `num_dets`, 尺寸 1x1，表示检测目标数量。 + +输出名: `boxes`, 尺寸 1x100x4，表示检测框的坐标，格式为 `x1y1x2y1`。 + +输出名: `scores`, 尺寸 1x100，表示检测框的分数。 + +输出名: `labels`, 尺寸 1x100，表示检测框的类别 id。 + +可以利用 `num_dets` 中的个数对 `boxes`, `scores`, `labels` 进行截断，从 100 个检测结果中抽取前 `num_dets` 个目标作为最终检测结果。 + +## 2. 仅导出模型 Backbone + Neck + +当您需要部署在非 `TensorRT`, `ONNXRuntime` 等支持端到端部署的平台时，您可以考虑使用`--model-only` 参数并且不要传递 `--backend` 参数，您将会导出仅包含 `Backbone` + `neck` 的模型，模型的部分输出如图: + +
+ +
+ +这种导出方式获取的 `ONNX` 模型具有如下优点: + +- 算子简单，一般而言只包含 `Conv`，激活函数等简单算子，几乎不存在无法正确导出的情况，对于嵌入式部署更加友好。 +- 方便不同算法之间对比速度性能，由于不同的算法后处理不同，仅对比 `backbone` + `Neck` 的速度更加公平。 + +也有如下缺点: + +- 后处理逻辑需要单独完成，会有额外的 `decode` + `nms` 的操作需要实现。 +- 与 `TensorRT` 相比，由于 `TensorRT` 可以利用多核优势并行进行后处理，使用 `--model-only` 方式导出的模型性能会差很多。 + +### 使用方法 + +```shell +python ./projects/easydeploy/tools/export.py \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5s.pth \ + --work-dir work_dir \ + --img-size 640 640 \ + --batch 1 \ + --device cpu \ + --simplify \ + --opset 11 \ + --model-only +``` + +## 使用 `model-only` 导出的 ONNX 进行推理 + +[模型推理脚本](./projects/easydeploy/examples/main_onnxruntime.py)用于推理导出的 `ONNX` 模型，需要安装基础依赖环境: + +[`onnxruntime`](https://github.com/microsoft/onnxruntime) 和 [`opencv-python`](https://github.com/opencv/opencv-python) + +```shell +pip install onnxruntime +pip install opencv-python==4.7.0.72 # 建议使用最新的 opencv +``` + +### 参数介绍: + +- `img` : 待检测的图片路径或图片文件夹路径。 +- `onnx` : 导出的 `model-only` ONNX 模型。 +- `--type` : 模型名称，目前支持 `yolov5`, `yolox`, `yolov6`, `ppyoloe`, `ppyoloep`, `yolov7`, `rtmdet`, `yolov8`。 +- `--img-size`: 转换模型时输入的尺寸，如 `640 640`。 +- `--out-dir`: 保存检测结果的路径 。 +- `--show`: 是否可视化检测结果。 +- `--score-thr`: 模型检测后处理的置信度分数 。 +- `--iou-thr`: 模型检测后处理的 IOU 分数 。 + +## 使用方法 + +```shell +cd ./projects/easydeploy/examples +python main_onnxruntime.py \ + "image_path_to_detect" \ + yolov5_s_model-only.onnx \ + --out-dir work_dir \ + --img-size 640 640 \ + --show \ + --score-thr 0.3 \ + --iou-thr 0.7 +``` + +*注意！！！* + +当您使用自定义数据集训练得到的模型时，请修改 [`config.py`](./projects/easydeploy/examples/config.py) 中 `CLASS_NAMES` 和 `CLASS_COLORS`，如果是 `yolov5` 或者 `yolov7` 基于 `anchor` 的模型请同时修改 `YOLOv5_ANCHORS` 和 `YOLOv7_ANCHORS`。 + +[`numpy_coder.py`](./projects/easydeploy/examples/numpy_coder.py) 是目前所有算法仅使用 `numpy` 实现的 `decoder`，如果您对性能有较高的要求，可以参照相关代码改写为 `c/c++`。 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/config.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/config.py new file mode 100644 index 0000000000000000000000000000000000000000..4a85ff34273c22a356c9d6a3eaeb048b637b5f40 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/config.py @@ -0,0 +1,64 @@ +from enum import Enum + + +class TASK_TYPE(Enum): + DET = 'det' + SEG = 'seg' + POSE = 'pose' + + +class ModelType(Enum): + YOLOV5 = 'yolov5' + YOLOX = 'yolox' + PPYOLOE = 'ppyoloe' + PPYOLOEP = 'ppyoloep' + YOLOV6 = 'yolov6' + YOLOV7 = 'yolov7' + RTMDET = 'rtmdet' + YOLOV8 = 'yolov8' + + +CLASS_NAMES = ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', + 'train', 'truck', 'boat', 'traffic light', 'fire hydrant', + 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', + 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', + 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', + 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', + 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', + 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', + 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', + 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', + 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', + 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', + 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', + 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush') + +CLASS_COLORS = [(220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), + (106, 0, 228), (0, 60, 100), (0, 80, 100), (0, 0, 70), + (0, 0, 192), (250, 170, 30), (100, 170, 30), (220, 220, 0), + (175, 116, 175), (250, 0, 30), (165, 42, 42), (255, 77, 255), + (0, 226, 252), (182, 182, 255), (0, 82, 0), (120, 166, 157), + (110, 76, 0), (174, 57, 255), (199, 100, 0), (72, 0, 118), + (255, 179, 240), (0, 125, 92), (209, 0, 151), (188, 208, 182), + (0, 220, 176), (255, 99, 164), (92, 0, 73), (133, 129, 255), + (78, 180, 255), (0, 228, 0), (174, 255, 243), (45, 89, 255), + (134, 134, 103), (145, 148, 174), (255, 208, 186), + (197, 226, 255), (171, 134, 1), (109, 63, 54), (207, 138, 255), + (151, 0, 95), (9, 80, 61), (84, 105, 51), (74, 65, 105), + (166, 196, 102), (208, 195, 210), (255, 109, 65), + (0, 143, 149), (179, 0, 194), (209, 99, 106), (5, 121, 0), + (227, 255, 205), (147, 186, 208), (153, 69, 1), (3, 95, 161), + (163, 255, 0), (119, 0, 170), (0, 182, 199), (0, 165, 120), + (183, 130, 88), (95, 32, 0), (130, 114, 135), (110, 129, 133), + (166, 74, 118), (219, 142, 185), (79, 210, 114), (178, 90, 62), + (65, 70, 15), (127, 167, 115), (59, 105, 106), (142, 108, 45), + (196, 172, 0), (95, 54, 80), (128, 76, 255), (201, 57, 1), + (246, 0, 122), (191, 162, 208)] + +YOLOv5_ANCHORS = [[(10, 13), (16, 30), (33, 23)], + [(30, 61), (62, 45), (59, 119)], + [(116, 90), (156, 198), (373, 326)]] + +YOLOv7_ANCHORS = [[(12, 16), (19, 36), (40, 28)], + [(36, 75), (76, 55), (72, 146)], + [(142, 110), (192, 243), (459, 401)]] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/cv2_nms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/cv2_nms.py new file mode 100644 index 0000000000000000000000000000000000000000..79e376356b75339c796aeeb280cd8cdb52db8518 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/cv2_nms.py @@ -0,0 +1,36 @@ +from typing import List, Tuple, Union + +import cv2 +from numpy import ndarray + +MAJOR, MINOR = map(int, cv2.__version__.split('.')[:2]) +assert MAJOR == 4 + + +def non_max_suppression(boxes: Union[List[ndarray], Tuple[ndarray]], + scores: Union[List[float], Tuple[float]], + labels: Union[List[int], Tuple[int]], + conf_thres: float = 0.25, + iou_thres: float = 0.65) -> Tuple[List, List, List]: + if MINOR >= 7: + indices = cv2.dnn.NMSBoxesBatched(boxes, scores, labels, conf_thres, + iou_thres) + elif MINOR == 6: + indices = cv2.dnn.NMSBoxes(boxes, scores, conf_thres, iou_thres) + else: + indices = cv2.dnn.NMSBoxes(boxes, scores, conf_thres, + iou_thres).flatten() + + nmsd_boxes = [] + nmsd_scores = [] + nmsd_labels = [] + for idx in indices: + box = boxes[idx] + # x0y0wh -> x0y0x1y1 + box[2:] = box[:2] + box[2:] + score = scores[idx] + label = labels[idx] + nmsd_boxes.append(box) + nmsd_scores.append(score) + nmsd_labels.append(label) + return nmsd_boxes, nmsd_scores, nmsd_labels diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/main_onnxruntime.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/main_onnxruntime.py new file mode 100644 index 0000000000000000000000000000000000000000..bc0ad1b0f10ed6cbea8c8b3c0c5010ec7a760cb5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/main_onnxruntime.py @@ -0,0 +1,110 @@ +import math +import sys +from argparse import ArgumentParser +from pathlib import Path + +import cv2 +import onnxruntime +from config import (CLASS_COLORS, CLASS_NAMES, ModelType, YOLOv5_ANCHORS, + YOLOv7_ANCHORS) +from cv2_nms import non_max_suppression +from numpy_coder import Decoder +from preprocess import Preprocess +from tqdm import tqdm + +# Add __FILE__ to sys.path +sys.path.append(str(Path(__file__).resolve().parents[0])) + +IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', + '.tiff', '.webp') + + +def path_to_list(path: str): + path = Path(path) + if path.is_file() and path.suffix in IMG_EXTENSIONS: + res_list = [str(path.absolute())] + elif path.is_dir(): + res_list = [ + str(p.absolute()) for p in path.iterdir() + if p.suffix in IMG_EXTENSIONS + ] + else: + raise RuntimeError + return res_list + + +def parse_args(): + parser = ArgumentParser() + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('onnx', type=str, help='Onnx file') + parser.add_argument('--type', type=str, help='Model type') + parser.add_argument( + '--img-size', + nargs='+', + type=int, + default=[640, 640], + help='Image size of height and width') + parser.add_argument( + '--out-dir', default='./output', type=str, help='Path to output file') + parser.add_argument( + '--show', action='store_true', help='Show the detection results') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + parser.add_argument( + '--iou-thr', type=float, default=0.7, help='Bbox iou threshold') + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + out_dir = Path(args.out_dir) + model_type = ModelType(args.type.lower()) + + if not args.show: + out_dir.mkdir(parents=True, exist_ok=True) + + files = path_to_list(args.img) + session = onnxruntime.InferenceSession( + args.onnx, providers=['CPUExecutionProvider']) + preprocessor = Preprocess(model_type) + decoder = Decoder(model_type, model_only=True) + if model_type == ModelType.YOLOV5: + anchors = YOLOv5_ANCHORS + elif model_type == ModelType.YOLOV7: + anchors = YOLOv7_ANCHORS + else: + anchors = None + + for file in tqdm(files): + image = cv2.imread(file) + image_h, image_w = image.shape[:2] + img, (ratio_w, ratio_h) = preprocessor(image, args.img_size) + features = session.run(None, {'images': img}) + decoder_outputs = decoder( + features, + args.score_thr, + num_labels=len(CLASS_NAMES), + anchors=anchors) + nmsd_boxes, nmsd_scores, nmsd_labels = non_max_suppression( + *decoder_outputs, args.score_thr, args.iou_thr) + for box, score, label in zip(nmsd_boxes, nmsd_scores, nmsd_labels): + x0, y0, x1, y1 = box + x0 = math.floor(min(max(x0 / ratio_w, 1), image_w - 1)) + y0 = math.floor(min(max(y0 / ratio_h, 1), image_h - 1)) + x1 = math.ceil(min(max(x1 / ratio_w, 1), image_w - 1)) + y1 = math.ceil(min(max(y1 / ratio_h, 1), image_h - 1)) + cv2.rectangle(image, (x0, y0), (x1, y1), CLASS_COLORS[label], 2) + cv2.putText(image, f'{CLASS_NAMES[label]}: {score:.2f}', + (x0, y0 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, + (0, 255, 255), 2) + if args.show: + cv2.imshow('result', image) + cv2.waitKey(0) + else: + cv2.imwrite(f'{out_dir / Path(file).name}', image) + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/numpy_coder.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/numpy_coder.py new file mode 100644 index 0000000000000000000000000000000000000000..3011965597415b9b6b09fcfe950ea36702b51e57 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/numpy_coder.py @@ -0,0 +1,309 @@ +from typing import List, Tuple, Union + +import numpy as np +from config import ModelType +from numpy import ndarray + + +def softmax(x: ndarray, axis: int = -1) -> ndarray: + e_x = np.exp(x - np.max(x, axis=axis, keepdims=True)) + y = e_x / e_x.sum(axis=axis, keepdims=True) + return y + + +def sigmoid(x: ndarray) -> ndarray: + return 1. / (1. + np.exp(-x)) + + +class Decoder: + + def __init__(self, model_type: ModelType, model_only: bool = False): + self.model_type = model_type + self.model_only = model_only + self.boxes_pro = [] + self.scores_pro = [] + self.labels_pro = [] + self.is_logging = False + + def __call__(self, + feats: Union[List, Tuple], + conf_thres: float, + num_labels: int = 80, + **kwargs) -> Tuple: + if not self.is_logging: + print('Only support decode in batch==1') + self.is_logging = True + self.boxes_pro.clear() + self.scores_pro.clear() + self.labels_pro.clear() + + if self.model_only: + # transpose channel to last dim for easy decoding + feats = [ + np.ascontiguousarray(feat[0].transpose(1, 2, 0)) + for feat in feats + ] + else: + # ax620a horizonX3 transpose channel to last dim by default + feats = [np.ascontiguousarray(feat) for feat in feats] + if self.model_type == ModelType.YOLOV5: + self.__yolov5_decode(feats, conf_thres, num_labels, **kwargs) + elif self.model_type == ModelType.YOLOX: + self.__yolox_decode(feats, conf_thres, num_labels, **kwargs) + elif self.model_type in (ModelType.PPYOLOE, ModelType.PPYOLOEP): + self.__ppyoloe_decode(feats, conf_thres, num_labels, **kwargs) + elif self.model_type == ModelType.YOLOV6: + self.__yolov6_decode(feats, conf_thres, num_labels, **kwargs) + elif self.model_type == ModelType.YOLOV7: + self.__yolov7_decode(feats, conf_thres, num_labels, **kwargs) + elif self.model_type == ModelType.RTMDET: + self.__rtmdet_decode(feats, conf_thres, num_labels, **kwargs) + elif self.model_type == ModelType.YOLOV8: + self.__yolov8_decode(feats, conf_thres, num_labels, **kwargs) + else: + raise NotImplementedError + return self.boxes_pro, self.scores_pro, self.labels_pro + + def __yolov5_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + anchors: Union[List, Tuple] = kwargs.get( + 'anchors', + [[(10, 13), (16, 30), + (33, 23)], [(30, 61), (62, 45), + (59, 119)], [(116, 90), (156, 198), (373, 326)]]) + for i, feat in enumerate(feats): + stride = 8 << i + feat_h, feat_w, _ = feat.shape + anchor = anchors[i] + feat = sigmoid(feat) + feat = feat.reshape((feat_h, feat_w, len(anchor), -1)) + box_feat, conf_feat, score_feat = np.split(feat, [4, 5], -1) + + hIdx, wIdx, aIdx, _ = np.where(conf_feat > conf_thres) + + num_proposal = hIdx.size + if not num_proposal: + continue + + score_feat = score_feat[hIdx, wIdx, aIdx] * conf_feat[hIdx, wIdx, + aIdx] + boxes = box_feat[hIdx, wIdx, aIdx] + labels = score_feat.argmax(-1) + scores = score_feat.max(-1) + + indices = np.where(scores > conf_thres)[0] + if len(indices) == 0: + continue + + for idx in indices: + a_w, a_h = anchor[aIdx[idx]] + x, y, w, h = boxes[idx] + x = (x * 2.0 - 0.5 + wIdx[idx]) * stride + y = (y * 2.0 - 0.5 + hIdx[idx]) * stride + w = (w * 2.0)**2 * a_w + h = (h * 2.0)**2 * a_h + + x0 = x - w / 2 + y0 = y - h / 2 + + self.scores_pro.append(float(scores[idx])) + self.boxes_pro.append( + np.array([x0, y0, w, h], dtype=np.float32)) + self.labels_pro.append(int(labels[idx])) + + def __yolox_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + for i, feat in enumerate(feats): + stride = 8 << i + score_feat, box_feat, conf_feat = np.split( + feat, [num_labels, num_labels + 4], -1) + conf_feat = sigmoid(conf_feat) + + hIdx, wIdx, _ = np.where(conf_feat > conf_thres) + + num_proposal = hIdx.size + if not num_proposal: + continue + + score_feat = sigmoid(score_feat[hIdx, wIdx]) * conf_feat[hIdx, + wIdx] + boxes = box_feat[hIdx, wIdx] + labels = score_feat.argmax(-1) + scores = score_feat.max(-1) + indices = np.where(scores > conf_thres)[0] + + if len(indices) == 0: + continue + + for idx in indices: + score = scores[idx] + label = labels[idx] + + x, y, w, h = boxes[idx] + + x = (x + wIdx[idx]) * stride + y = (y + hIdx[idx]) * stride + w = np.exp(w) * stride + h = np.exp(h) * stride + + x0 = x - w / 2 + y0 = y - h / 2 + + self.scores_pro.append(float(score)) + self.boxes_pro.append( + np.array([x0, y0, w, h], dtype=np.float32)) + self.labels_pro.append(int(label)) + + def __ppyoloe_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + reg_max: int = kwargs.get('reg_max', 17) + dfl = np.arange(0, reg_max, dtype=np.float32) + for i, feat in enumerate(feats): + stride = 8 << i + score_feat, box_feat = np.split(feat, [ + num_labels, + ], -1) + score_feat = sigmoid(score_feat) + _argmax = score_feat.argmax(-1) + _max = score_feat.max(-1) + indices = np.where(_max > conf_thres) + hIdx, wIdx = indices + num_proposal = hIdx.size + if not num_proposal: + continue + + scores = _max[hIdx, wIdx] + boxes = box_feat[hIdx, wIdx].reshape(num_proposal, 4, reg_max) + boxes = softmax(boxes, -1) @ dfl + labels = _argmax[hIdx, wIdx] + + for k in range(num_proposal): + score = scores[k] + label = labels[k] + + x0, y0, x1, y1 = boxes[k] + + x0 = (wIdx[k] + 0.5 - x0) * stride + y0 = (hIdx[k] + 0.5 - y0) * stride + x1 = (wIdx[k] + 0.5 + x1) * stride + y1 = (hIdx[k] + 0.5 + y1) * stride + + w = x1 - x0 + h = y1 - y0 + + self.scores_pro.append(float(score)) + self.boxes_pro.append( + np.array([x0, y0, w, h], dtype=np.float32)) + self.labels_pro.append(int(label)) + + def __yolov6_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + for i, feat in enumerate(feats): + stride = 8 << i + score_feat, box_feat = np.split(feat, [ + num_labels, + ], -1) + score_feat = sigmoid(score_feat) + _argmax = score_feat.argmax(-1) + _max = score_feat.max(-1) + indices = np.where(_max > conf_thres) + hIdx, wIdx = indices + num_proposal = hIdx.size + if not num_proposal: + continue + + scores = _max[hIdx, wIdx] + boxes = box_feat[hIdx, wIdx] + labels = _argmax[hIdx, wIdx] + + for k in range(num_proposal): + score = scores[k] + label = labels[k] + + x0, y0, x1, y1 = boxes[k] + + x0 = (wIdx[k] + 0.5 - x0) * stride + y0 = (hIdx[k] + 0.5 - y0) * stride + x1 = (wIdx[k] + 0.5 + x1) * stride + y1 = (hIdx[k] + 0.5 + y1) * stride + + w = x1 - x0 + h = y1 - y0 + + self.scores_pro.append(float(score)) + self.boxes_pro.append( + np.array([x0, y0, w, h], dtype=np.float32)) + self.labels_pro.append(int(label)) + + def __yolov7_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + anchors: Union[List, Tuple] = kwargs.get( + 'anchors', + [[(12, 16), (19, 36), + (40, 28)], [(36, 75), (76, 55), + (72, 146)], [(142, 110), (192, 243), (459, 401)]]) + self.__yolov5_decode(feats, conf_thres, num_labels, anchors=anchors) + + def __rtmdet_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + for i, feat in enumerate(feats): + stride = 8 << i + score_feat, box_feat = np.split(feat, [ + num_labels, + ], -1) + score_feat = sigmoid(score_feat) + _argmax = score_feat.argmax(-1) + _max = score_feat.max(-1) + indices = np.where(_max > conf_thres) + hIdx, wIdx = indices + num_proposal = hIdx.size + if not num_proposal: + continue + + scores = _max[hIdx, wIdx] + boxes = box_feat[hIdx, wIdx] + labels = _argmax[hIdx, wIdx] + + for k in range(num_proposal): + score = scores[k] + label = labels[k] + + x0, y0, x1, y1 = boxes[k] + + x0 = (wIdx[k] - x0) * stride + y0 = (hIdx[k] - y0) * stride + x1 = (wIdx[k] + x1) * stride + y1 = (hIdx[k] + y1) * stride + + w = x1 - x0 + h = y1 - y0 + + self.scores_pro.append(float(score)) + self.boxes_pro.append( + np.array([x0, y0, w, h], dtype=np.float32)) + self.labels_pro.append(int(label)) + + def __yolov8_decode(self, + feats: List[ndarray], + conf_thres: float, + num_labels: int = 80, + **kwargs): + self.__yolov6_decode(feats, conf_thres, num_labels) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/preprocess.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/preprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6fb563a16a7f40ef556b5a23f635ab4627fc4f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/preprocess.py @@ -0,0 +1,57 @@ +from typing import List, Tuple, Union + +import cv2 +import numpy as np +from config import ModelType +from numpy import ndarray + + +class Preprocess: + + def __init__(self, model_type: ModelType): + if model_type in (ModelType.YOLOV5, ModelType.YOLOV6, ModelType.YOLOV7, + ModelType.YOLOV8): + mean = np.array([0, 0, 0], dtype=np.float32) + std = np.array([255, 255, 255], dtype=np.float32) + is_rgb = True + elif model_type == ModelType.YOLOX: + mean = np.array([0, 0, 0], dtype=np.float32) + std = np.array([1, 1, 1], dtype=np.float32) + is_rgb = False + elif model_type == ModelType.PPYOLOE: + mean = np.array([123.675, 116.28, 103.53], dtype=np.float32) + std = np.array([58.395, 57.12, 57.375], dtype=np.float32) + is_rgb = True + + elif model_type == ModelType.PPYOLOEP: + mean = np.array([0, 0, 0], dtype=np.float32) + std = np.array([255, 255, 255], dtype=np.float32) + is_rgb = True + elif model_type == ModelType.RTMDET: + mean = np.array([103.53, 116.28, 123.675], dtype=np.float32) + std = np.array([57.375, 57.12, 58.3955], dtype=np.float32) + is_rgb = False + else: + raise NotImplementedError + + self.mean = mean.reshape((3, 1, 1)) + self.std = std.reshape((3, 1, 1)) + self.is_rgb = is_rgb + + def __call__(self, + image: ndarray, + new_size: Union[List[int], Tuple[int]] = (640, 640), + **kwargs) -> Tuple[ndarray, Tuple[float, float]]: + # new_size: (height, width) + height, width = image.shape[:2] + ratio_h, ratio_w = new_size[0] / height, new_size[1] / width + image = cv2.resize( + image, (0, 0), + fx=ratio_w, + fy=ratio_h, + interpolation=cv2.INTER_LINEAR) + image = np.ascontiguousarray(image.transpose(2, 0, 1)) + image = image.astype(np.float32) + image -= self.mean + image /= self.std + return image[np.newaxis], (ratio_w, ratio_h) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/requirements.txt b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..0b761189b52fc57e4231b37df0ff42bb44404c95 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/examples/requirements.txt @@ -0,0 +1,2 @@ +onnxruntime +opencv-python==4.7.0.72 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..38af8bc322b0a8e0c870fac243a0af9c1dba7315 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from .backend import MMYOLOBackend +from .backendwrapper import ORTWrapper, TRTWrapper +from .model import DeployModel + +__all__ = ['DeployModel', 'TRTWrapper', 'ORTWrapper', 'MMYOLOBackend'] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/backend.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/backend.py new file mode 100644 index 0000000000000000000000000000000000000000..64d6e3f020bcfd3c3cf7db5f5611a8f815df4cb1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/backend.py @@ -0,0 +1,23 @@ +from enum import Enum + +import torch +import torch.nn.functional as F + + +class MMYOLOBackend(Enum): + AX620A = 'ax620a' + COREML = 'coreml' + HORIZONX3 = 'horizonx3' + NCNN = 'ncnn' + ONNXRUNTIME = 'onnxruntime' + OPENVINO = 'openvino' + PPLNN = 'pplnn' + RKNN = 'rknn' + TENSORRT8 = 'tensorrt8' + TENSORRT7 = 'tensorrt7' + TORCHSCRIPT = 'torchscript' + TVM = 'tvm' + + +def HSigmoid__forward(self, x: torch.Tensor) -> torch.Tensor: + return F.hardsigmoid(x, inplace=True) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/backendwrapper.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/backendwrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..2997d84ea98b3f30973cf2335ab0eb4af4edaef5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/backendwrapper.py @@ -0,0 +1,202 @@ +import warnings +from collections import namedtuple +from functools import partial +from pathlib import Path +from typing import List, Optional, Union + +import numpy as np +import onnxruntime + +try: + import tensorrt as trt +except Exception: + trt = None +import torch + +warnings.filterwarnings(action='ignore', category=DeprecationWarning) + + +class TRTWrapper(torch.nn.Module): + dtype_mapping = {} + + def __init__(self, weight: Union[str, Path], + device: Optional[torch.device]): + super().__init__() + weight = Path(weight) if isinstance(weight, str) else weight + assert weight.exists() and weight.suffix in ('.engine', '.plan') + if isinstance(device, str): + device = torch.device(device) + elif isinstance(device, int): + device = torch.device(f'cuda:{device}') + self.weight = weight + self.device = device + self.stream = torch.cuda.Stream(device=device) + self.__update_mapping() + self.__init_engine() + self.__init_bindings() + + def __update_mapping(self): + self.dtype_mapping.update({ + trt.bool: torch.bool, + trt.int8: torch.int8, + trt.int32: torch.int32, + trt.float16: torch.float16, + trt.float32: torch.float32 + }) + + def __init_engine(self): + logger = trt.Logger(trt.Logger.ERROR) + self.log = partial(logger.log, trt.Logger.ERROR) + trt.init_libnvinfer_plugins(logger, namespace='') + self.logger = logger + with trt.Runtime(logger) as runtime: + model = runtime.deserialize_cuda_engine(self.weight.read_bytes()) + + context = model.create_execution_context() + + names = [model.get_binding_name(i) for i in range(model.num_bindings)] + + num_inputs, num_outputs = 0, 0 + + for i in range(model.num_bindings): + if model.binding_is_input(i): + num_inputs += 1 + else: + num_outputs += 1 + + self.is_dynamic = -1 in model.get_binding_shape(0) + + self.model = model + self.context = context + self.input_names = names[:num_inputs] + self.output_names = names[num_inputs:] + self.num_inputs = num_inputs + self.num_outputs = num_outputs + self.num_bindings = num_inputs + num_outputs + self.bindings: List[int] = [0] * self.num_bindings + + def __init_bindings(self): + Binding = namedtuple('Binding', ('name', 'dtype', 'shape')) + inputs_info = [] + outputs_info = [] + + for i, name in enumerate(self.input_names): + assert self.model.get_binding_name(i) == name + dtype = self.dtype_mapping[self.model.get_binding_dtype(i)] + shape = tuple(self.model.get_binding_shape(i)) + inputs_info.append(Binding(name, dtype, shape)) + + for i, name in enumerate(self.output_names): + i += self.num_inputs + assert self.model.get_binding_name(i) == name + dtype = self.dtype_mapping[self.model.get_binding_dtype(i)] + shape = tuple(self.model.get_binding_shape(i)) + outputs_info.append(Binding(name, dtype, shape)) + self.inputs_info = inputs_info + self.outputs_info = outputs_info + if not self.is_dynamic: + self.output_tensor = [ + torch.empty(o.shape, dtype=o.dtype, device=self.device) + for o in outputs_info + ] + + def forward(self, *inputs): + + assert len(inputs) == self.num_inputs + + contiguous_inputs: List[torch.Tensor] = [ + i.contiguous() for i in inputs + ] + + for i in range(self.num_inputs): + self.bindings[i] = contiguous_inputs[i].data_ptr() + if self.is_dynamic: + self.context.set_binding_shape( + i, tuple(contiguous_inputs[i].shape)) + + # create output tensors + outputs: List[torch.Tensor] = [] + + for i in range(self.num_outputs): + j = i + self.num_inputs + if self.is_dynamic: + shape = tuple(self.context.get_binding_shape(j)) + output = torch.empty( + size=shape, + dtype=self.output_dtypes[i], + device=self.device) + + else: + output = self.output_tensor[i] + outputs.append(output) + self.bindings[j] = output.data_ptr() + + self.context.execute_async_v2(self.bindings, self.stream.cuda_stream) + self.stream.synchronize() + + return tuple(outputs) + + +class ORTWrapper(torch.nn.Module): + + def __init__(self, weight: Union[str, Path], + device: Optional[torch.device]): + super().__init__() + weight = Path(weight) if isinstance(weight, str) else weight + assert weight.exists() and weight.suffix == '.onnx' + + if isinstance(device, str): + device = torch.device(device) + elif isinstance(device, int): + device = torch.device(f'cuda:{device}') + self.weight = weight + self.device = device + self.__init_session() + self.__init_bindings() + + def __init_session(self): + providers = ['CPUExecutionProvider'] + if 'cuda' in self.device.type: + providers.insert(0, 'CUDAExecutionProvider') + + session = onnxruntime.InferenceSession( + str(self.weight), providers=providers) + self.session = session + + def __init_bindings(self): + Binding = namedtuple('Binding', ('name', 'dtype', 'shape')) + inputs_info = [] + outputs_info = [] + self.is_dynamic = False + for i, tensor in enumerate(self.session.get_inputs()): + if any(not isinstance(i, int) for i in tensor.shape): + self.is_dynamic = True + inputs_info.append( + Binding(tensor.name, tensor.type, tuple(tensor.shape))) + + for i, tensor in enumerate(self.session.get_outputs()): + outputs_info.append( + Binding(tensor.name, tensor.type, tuple(tensor.shape))) + self.inputs_info = inputs_info + self.outputs_info = outputs_info + self.num_inputs = len(inputs_info) + + def forward(self, *inputs): + + assert len(inputs) == self.num_inputs + + contiguous_inputs: List[np.ndarray] = [ + i.contiguous().cpu().numpy() for i in inputs + ] + + if not self.is_dynamic: + # make sure input shape is right for static input shape + for i in range(self.num_inputs): + assert contiguous_inputs[i].shape == self.inputs_info[i].shape + + outputs = self.session.run([o.name for o in self.outputs_info], { + j.name: contiguous_inputs[i] + for i, j in enumerate(self.inputs_info) + }) + + return tuple(torch.from_numpy(o).to(self.device) for o in outputs) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/model.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/model.py new file mode 100644 index 0000000000000000000000000000000000000000..21cf50f7df059ebc7d1974754d290883c06f6a0e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/model/model.py @@ -0,0 +1,217 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from copy import deepcopy +from functools import partial +from typing import List, Optional, Tuple + +import torch +import torch.nn as nn +from mmdet.models.backbones.csp_darknet import Focus +from mmdet.models.layers import ChannelAttention +from mmengine.config import ConfigDict +from torch import Tensor + +from mmyolo.models import RepVGGBlock +from mmyolo.models.dense_heads import (PPYOLOEHead, RTMDetHead, YOLOv5Head, + YOLOv7Head, YOLOv8Head, YOLOXHead) +from mmyolo.models.layers import ImplicitA, ImplicitM +from ..backbone import DeployFocus, GConvFocus, NcnnFocus +from ..bbox_code import (rtmdet_bbox_decoder, yolov5_bbox_decoder, + yolox_bbox_decoder) +from ..nms import batched_nms, efficient_nms, onnx_nms +from .backend import MMYOLOBackend + + +class DeployModel(nn.Module): + transpose = False + + def __init__(self, + baseModel: nn.Module, + backend: MMYOLOBackend, + postprocess_cfg: Optional[ConfigDict] = None, + with_nms=True, + without_bbox_decoder=False): + super().__init__() + self.baseModel = baseModel + self.baseHead = baseModel.bbox_head + self.backend = backend + self.with_nms = with_nms + self.without_bbox_decoder = without_bbox_decoder + if postprocess_cfg is None: + self.with_postprocess = False + else: + self.with_postprocess = True + self.__init_sub_attributes() + self.detector_type = type(self.baseHead) + self.pre_top_k = postprocess_cfg.get('pre_top_k', 1000) + self.keep_top_k = postprocess_cfg.get('keep_top_k', 100) + self.iou_threshold = postprocess_cfg.get('iou_threshold', 0.65) + self.score_threshold = postprocess_cfg.get('score_threshold', 0.25) + self.__switch_deploy() + + def __init_sub_attributes(self): + self.bbox_decoder = self.baseHead.bbox_coder.decode + self.prior_generate = self.baseHead.prior_generator.grid_priors + self.num_base_priors = self.baseHead.num_base_priors + self.featmap_strides = self.baseHead.featmap_strides + self.num_classes = self.baseHead.num_classes + + def __switch_deploy(self): + headType = type(self.baseHead) + if not self.with_postprocess: + if headType in (YOLOv5Head, YOLOv7Head): + self.baseHead.head_module.forward_single = self.forward_single + elif headType in (PPYOLOEHead, YOLOv8Head): + self.baseHead.head_module.reg_max = 0 + + if self.backend in (MMYOLOBackend.HORIZONX3, MMYOLOBackend.NCNN, + MMYOLOBackend.TORCHSCRIPT): + self.transpose = True + for layer in self.baseModel.modules(): + if isinstance(layer, RepVGGBlock): + layer.switch_to_deploy() + elif isinstance(layer, ChannelAttention): + layer.global_avgpool.forward = self.forward_gvp + elif isinstance(layer, Focus): + # onnxruntime openvino tensorrt8 tensorrt7 + if self.backend in (MMYOLOBackend.ONNXRUNTIME, + MMYOLOBackend.OPENVINO, + MMYOLOBackend.TENSORRT8, + MMYOLOBackend.TENSORRT7): + self.baseModel.backbone.stem = DeployFocus(layer) + # ncnn + elif self.backend == MMYOLOBackend.NCNN: + self.baseModel.backbone.stem = NcnnFocus(layer) + # switch focus to group conv + else: + self.baseModel.backbone.stem = GConvFocus(layer) + + def pred_by_feat(self, + cls_scores: List[Tensor], + bbox_preds: List[Tensor], + objectnesses: Optional[List[Tensor]] = None, + coeff_preds: Optional[List[Tensor]] = None, + proto_preds: Optional[List[Tensor]] = None, + **kwargs): + assert len(cls_scores) == len(bbox_preds) + dtype = cls_scores[0].dtype + device = cls_scores[0].device + + nms_func = self.select_nms() + if self.detector_type in (YOLOv5Head, YOLOv7Head): + bbox_decoder = yolov5_bbox_decoder + elif self.detector_type is RTMDetHead: + bbox_decoder = rtmdet_bbox_decoder + elif self.detector_type is YOLOXHead: + bbox_decoder = yolox_bbox_decoder + else: + bbox_decoder = self.bbox_decoder + print(bbox_decoder) + + num_imgs = cls_scores[0].shape[0] + featmap_sizes = [cls_score.shape[2:] for cls_score in cls_scores] + + mlvl_priors = self.prior_generate(featmap_sizes, + dtype=dtype, + device=device) + + flatten_priors = torch.cat(mlvl_priors) + mlvl_strides = [ + flatten_priors.new_full( + (featmap_size[0] * featmap_size[1] * self.num_base_priors, ), + stride) for featmap_size, stride in zip( + featmap_sizes, self.featmap_strides) + ] + flatten_stride = torch.cat(mlvl_strides) + + text_len = cls_scores[0].shape[1] + flatten_cls_scores = [ + cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1, text_len) + for cls_score in cls_scores + ] + cls_scores = torch.cat(flatten_cls_scores, dim=1).sigmoid() + + flatten_bbox_preds = [ + bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4) + for bbox_pred in bbox_preds + ] + flatten_bbox_preds = torch.cat(flatten_bbox_preds, dim=1) + + if objectnesses is not None: + flatten_objectness = [ + objectness.permute(0, 2, 3, 1).reshape(num_imgs, -1) + for objectness in objectnesses + ] + flatten_objectness = torch.cat(flatten_objectness, dim=1).sigmoid() + cls_scores = cls_scores * (flatten_objectness.unsqueeze(-1)) + + scores = cls_scores + bboxes = flatten_bbox_preds + if self.without_bbox_decoder: + return scores, bboxes + bboxes = bbox_decoder(flatten_priors[None], flatten_bbox_preds, + flatten_stride) + + if self.with_nms: + return nms_func(bboxes, scores, self.keep_top_k, + self.iou_threshold, self.score_threshold, + self.pre_top_k, self.keep_top_k) + else: + return scores, bboxes + + def select_nms(self): + if self.backend in (MMYOLOBackend.ONNXRUNTIME, MMYOLOBackend.OPENVINO): + nms_func = onnx_nms + elif self.backend == MMYOLOBackend.TENSORRT8: + nms_func = efficient_nms + elif self.backend == MMYOLOBackend.TENSORRT7: + nms_func = batched_nms + else: + raise NotImplementedError + if type(self.baseHead) in (YOLOv5Head, YOLOv7Head, YOLOXHead): + nms_func = partial(nms_func, box_coding=1) + + return nms_func + + def forward(self, inputs: Tensor): + neck_outputs = self.baseModel(inputs) + if self.with_postprocess: + return self.pred_by_feat(*neck_outputs) + else: + outputs = [] + if self.transpose: + for feats in zip(*neck_outputs): + if self.backend in (MMYOLOBackend.NCNN, + MMYOLOBackend.TORCHSCRIPT): + outputs.append( + torch.cat( + [feat.permute(0, 2, 3, 1) for feat in feats], + -1)) + else: + outputs.append(torch.cat(feats, 1).permute(0, 2, 3, 1)) + else: + for feats in zip(*neck_outputs): + outputs.append(torch.cat(feats, 1)) + return tuple(outputs) + + @staticmethod + def forward_single(x: Tensor, convs: nn.Module) -> Tuple[Tensor]: + if isinstance(convs, nn.Sequential) and any( + type(m) in (ImplicitA, ImplicitM) for m in convs): + a, c, m = convs + aw = a.implicit.clone() + mw = m.implicit.clone() + c = deepcopy(c) + nw, cw, _, _ = c.weight.shape + na, ca, _, _ = aw.shape + nm, cm, _, _ = mw.shape + c.bias = nn.Parameter(c.bias + ( + c.weight.reshape(nw, cw) @ aw.reshape(ca, na)).squeeze(1)) + c.bias = nn.Parameter(c.bias * mw.reshape(cm)) + c.weight = nn.Parameter(c.weight * mw.transpose(0, 1)) + convs = c + feat = convs(x) + return (feat, ) + + @staticmethod + def forward_gvp(x: Tensor) -> Tensor: + return torch.mean(x, [2, 3], keepdim=True) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/__init__.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..59c5cdbd2b3b195125a14f473b825f616755fd6e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/__init__.py @@ -0,0 +1,5 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from .ort_nms import onnx_nms +from .trt_nms import batched_nms, efficient_nms + +__all__ = ['efficient_nms', 'batched_nms', 'onnx_nms'] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/ort_nms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/ort_nms.py new file mode 100644 index 0000000000000000000000000000000000000000..597f3fb6f33c5bf182aa9c5ba4740e53168b005a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/ort_nms.py @@ -0,0 +1,215 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +from torch import Tensor +from torchvision.ops import batched_nms + +_XYWH2XYXY = torch.tensor([[1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 1.0], + [-0.5, 0.0, 0.5, 0.0], [0.0, -0.5, 0.0, 0.5]], + dtype=torch.float32) + + +def sort_nms_index(nms_index, scores, batch_size, keep_top_k=-1): + """ + first sort the nms_index by batch, and then sort by score in every image result, final apply keep_top_k strategy. In the process, we can also get the number of detections for each image: num_dets + """ + # first sort by batch index to make sure that the same batch index is together + device = nms_index.device + nms_index_indices = torch.argsort(nms_index[:, 0], dim=0).to(device) + nms_index = nms_index[nms_index_indices] + + scores = scores[nms_index[:, 0], nms_index[:, 1], nms_index[:, 2]] + batch_inds = nms_index[:, 0] + + # Get the number of detections for each image + num_dets = torch.bincount(batch_inds,minlength=batch_size).to(device) + # Calculate the sum from front to back + cumulative_sum = torch.cumsum(num_dets, dim=0).to(device) + # add initial value 0 + cumulative_sum = torch.cat((torch.tensor([0]).to(device), cumulative_sum)) + for i in range(len(num_dets)): + start = cumulative_sum[i] + end = cumulative_sum[i + 1] + # sort by score in every batch + block_idx = torch.argsort(scores[start:end], descending=True).to(device) + nms_index[start:end] = nms_index[start:end][block_idx] + if keep_top_k > 0 and end - start > keep_top_k: + # delete lines from start+keep_top_k to end to keep only top k + nms_index = torch.cat( + (nms_index[: start + keep_top_k], nms_index[end:]), dim=0 + ) + num_dets[i] -= end - start - keep_top_k + cumulative_sum -= end - start - keep_top_k + return nms_index, num_dets + + +def select_nms_index( + scores: Tensor, + boxes: Tensor, + nms_index: Tensor, + batch_size: int, + keep_top_k: int = -1, +): + if nms_index.numel() == 0: + return torch.empty(0), torch.empty(0, 4), torch.empty(0), torch.empty(0) + nms_index, num_dets = sort_nms_index(nms_index, scores, batch_size, keep_top_k) + batch_inds, cls_inds = nms_index[:, 0], nms_index[:, 1] + box_inds = nms_index[:, 2] + + # according to the nms_index to get the scores,boxes and labels + batched_scores = scores[batch_inds, cls_inds, box_inds] + batched_dets = boxes[batch_inds, box_inds, ...] + batched_labels = cls_inds + + return num_dets, batched_dets, batched_scores, batched_labels + + +def construct_indice(batch_idx, select_bbox_idxs, class_idxs, original_idxs): + num_bbox = len(select_bbox_idxs) + class_idxs = class_idxs[select_bbox_idxs] + indice = torch.zeros((num_bbox, 3), dtype=torch.int32).to(select_bbox_idxs.device) + # batch_idx + indice[:, 0] = batch_idx + # class_idxs + indice[:, 1] = class_idxs + # select_bbox_idxs + indice[:, 2] = original_idxs[select_bbox_idxs] + return indice + + +def filter_max_boxes_per_class( + select_bbox_idxs, class_idxs, max_output_boxes_per_class +): + class_counts = {} # used to track the count of each class + + filtered_select_bbox_idxs = [] + filtered_max_class_idxs = [] + + for bbox_idx, class_idx in zip(select_bbox_idxs, class_idxs): + class_count = class_counts.get( + class_idx.item(), 0 + ) # Get the count of the current class, or return 0 if it does not exist + if class_count < max_output_boxes_per_class: + filtered_select_bbox_idxs.append(bbox_idx) + filtered_max_class_idxs.append(class_idx) + class_counts[class_idx.item()] = class_count + 1 + return torch.tensor(filtered_select_bbox_idxs), torch.tensor( + filtered_max_class_idxs + ) + + +class ONNXNMSop(torch.autograd.Function): + + @staticmethod + def forward( + ctx, + boxes: Tensor, + scores: Tensor, + max_output_boxes_per_class: Tensor = torch.tensor([100]), + iou_threshold: Tensor = torch.tensor([0.5]), + score_threshold: Tensor = torch.tensor([0.05]) + ) -> Tensor: + """ + Non-Maximum Suppression (NMS) implementation. + + Args: + boxes (Tensor): Bounding boxes of shape (batch_size, num_boxes, 4). + scores (Tensor): Confidence scores of shape (batch_size, num_classes, num_boxes). + max_output_boxes_per_class (Tensor): Maximum number of output boxes per class. + iou_threshold (Tensor): IoU threshold for NMS. + score_threshold (Tensor): Confidence score threshold. + + Returns: + Tensor: Selected indices of shape (num_det, 3).first value is batch index, second value is class index, third value is box index + """ + device = boxes.device + batch_size, num_classes, num_boxes = scores.shape + selected_indices = [] + for batch_idx in range(batch_size): + boxes_per_image = boxes[batch_idx] + scores_per_image = scores[batch_idx] + + # If no boxes in this image, continue to the next image + if boxes_per_image.numel() == 0: + continue + + # for one box, only exist one class,so use torch.max to get the max score and class index + scores_per_image, class_idxs = torch.max(scores_per_image, dim=0) + # Apply score threshold before batched_nms bacause nms operation is time expensive + keep_idxs = scores_per_image > score_threshold + if not torch.any(keep_idxs): + # If no boxes left after applying score threshold, continue to the next image + continue + + boxes_per_image = boxes_per_image[keep_idxs] + scores_per_image = scores_per_image[keep_idxs] + class_idxs = class_idxs[keep_idxs] + + # The purpose of original_idxs is we want to return the indexs to the original input data instead of the filtered. + original_idxs = torch.arange(num_boxes, device=device)[keep_idxs] + # reference: https://pytorch.org/vision/main/generated/torchvision.ops.batched_nms.html + select_bbox_idxs = batched_nms( + boxes_per_image, scores_per_image, class_idxs, iou_threshold + ) + if ( + select_bbox_idxs.shape[0] > max_output_boxes_per_class + ): # If the boxes detected by all classes together are less than max_output_boxes_per_class, then there is no need to filter + select_bbox_idxs, _ = filter_max_boxes_per_class( + select_bbox_idxs, + class_idxs[select_bbox_idxs], + max_output_boxes_per_class, + ) + selected_indice = construct_indice( + batch_idx, select_bbox_idxs, class_idxs, original_idxs + ) + selected_indices.append(selected_indice) + if len(selected_indices) == 0: + return torch.tensor([], device=device) + selected_indices = torch.cat(selected_indices, dim=0) + return selected_indices + + @staticmethod + def symbolic( + g, + boxes: Tensor, + scores: Tensor, + max_output_boxes_per_class: Tensor = torch.tensor([100]), + iou_threshold: Tensor = torch.tensor([0.5]), + score_threshold: Tensor = torch.tensor([0.05]), + ): + return g.op( + 'NonMaxSuppression', + boxes, + scores, + max_output_boxes_per_class, + iou_threshold, + score_threshold, + outputs=1) + + +def onnx_nms( + boxes: torch.Tensor, + scores: torch.Tensor, + max_output_boxes_per_class: int = 100, + iou_threshold: float = 0.5, + score_threshold: float = 0.05, + pre_top_k: int = -1, + keep_top_k: int = 100, + box_coding: int = 0, +): + max_output_boxes_per_class = torch.tensor([max_output_boxes_per_class]) + iou_threshold = torch.tensor([iou_threshold]).to(boxes.device) + score_threshold = torch.tensor([score_threshold]).to(boxes.device) + + batch_size, _, _ = scores.shape + if box_coding == 1: + boxes = boxes @ (_XYWH2XYXY.to(boxes.device)) + scores = scores.transpose(1, 2).contiguous() + selected_indices = ONNXNMSop.apply(boxes, scores, + max_output_boxes_per_class, + iou_threshold, score_threshold) + + num_dets, batched_dets, batched_scores, batched_labels = select_nms_index( + scores, boxes, selected_indices, batch_size, keep_top_k=keep_top_k) + + return num_dets, batched_dets, batched_scores, batched_labels.to( + torch.int32) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/trt_nms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/trt_nms.py new file mode 100644 index 0000000000000000000000000000000000000000..e0db1e2164d4366ff9ce4f74d39ded917c39ba79 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/nms/trt_nms.py @@ -0,0 +1,226 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import torch +from torch import Tensor + +_XYWH2XYXY = torch.tensor([[1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 1.0], + [-0.5, 0.0, 0.5, 0.0], [0.0, -0.5, 0.0, 0.5]], + dtype=torch.float32) + + +class TRTEfficientNMSop(torch.autograd.Function): + + @staticmethod + def forward( + ctx, + boxes: Tensor, + scores: Tensor, + background_class: int = -1, + box_coding: int = 0, + iou_threshold: float = 0.45, + max_output_boxes: int = 100, + plugin_version: str = '1', + score_activation: int = 0, + score_threshold: float = 0.25, + ): + batch_size, _, num_classes = scores.shape + num_det = torch.randint( + 0, max_output_boxes, (batch_size, 1), dtype=torch.int32) + det_boxes = torch.randn(batch_size, max_output_boxes, 4) + det_scores = torch.randn(batch_size, max_output_boxes) + det_classes = torch.randint( + 0, num_classes, (batch_size, max_output_boxes), dtype=torch.int32) + return num_det, det_boxes, det_scores, det_classes + + @staticmethod + def symbolic(g, + boxes: Tensor, + scores: Tensor, + background_class: int = -1, + box_coding: int = 0, + iou_threshold: float = 0.45, + max_output_boxes: int = 100, + plugin_version: str = '1', + score_activation: int = 0, + score_threshold: float = 0.25): + out = g.op( + 'TRT::EfficientNMS_TRT', + boxes, + scores, + background_class_i=background_class, + box_coding_i=box_coding, + iou_threshold_f=iou_threshold, + max_output_boxes_i=max_output_boxes, + plugin_version_s=plugin_version, + score_activation_i=score_activation, + score_threshold_f=score_threshold, + outputs=4) + num_det, det_boxes, det_scores, det_classes = out + return num_det, det_boxes, det_scores, det_classes + + +class TRTbatchedNMSop(torch.autograd.Function): + """TensorRT NMS operation.""" + + @staticmethod + def forward( + ctx, + boxes: Tensor, + scores: Tensor, + plugin_version: str = '1', + shareLocation: int = 1, + backgroundLabelId: int = -1, + numClasses: int = 80, + topK: int = 1000, + keepTopK: int = 100, + scoreThreshold: float = 0.25, + iouThreshold: float = 0.45, + isNormalized: int = 0, + clipBoxes: int = 0, + scoreBits: int = 16, + caffeSemantics: int = 1, + ): + batch_size, _, numClasses = scores.shape + num_det = torch.randint( + 0, keepTopK, (batch_size, 1), dtype=torch.int32) + det_boxes = torch.randn(batch_size, keepTopK, 4) + det_scores = torch.randn(batch_size, keepTopK) + det_classes = torch.randint(0, numClasses, + (batch_size, keepTopK)).float() + return num_det, det_boxes, det_scores, det_classes + + @staticmethod + def symbolic( + g, + boxes: Tensor, + scores: Tensor, + plugin_version: str = '1', + shareLocation: int = 1, + backgroundLabelId: int = -1, + numClasses: int = 80, + topK: int = 1000, + keepTopK: int = 100, + scoreThreshold: float = 0.25, + iouThreshold: float = 0.45, + isNormalized: int = 0, + clipBoxes: int = 0, + scoreBits: int = 16, + caffeSemantics: int = 1, + ): + out = g.op( + 'TRT::BatchedNMSDynamic_TRT', + boxes, + scores, + shareLocation_i=shareLocation, + plugin_version_s=plugin_version, + backgroundLabelId_i=backgroundLabelId, + numClasses_i=numClasses, + topK_i=topK, + keepTopK_i=keepTopK, + scoreThreshold_f=scoreThreshold, + iouThreshold_f=iouThreshold, + isNormalized_i=isNormalized, + clipBoxes_i=clipBoxes, + scoreBits_i=scoreBits, + caffeSemantics_i=caffeSemantics, + outputs=4) + num_det, det_boxes, det_scores, det_classes = out + return num_det, det_boxes, det_scores, det_classes + + +def _efficient_nms( + boxes: Tensor, + scores: Tensor, + max_output_boxes_per_class: int = 1000, + iou_threshold: float = 0.5, + score_threshold: float = 0.05, + pre_top_k: int = -1, + keep_top_k: int = 100, + box_coding: int = 0, +): + """Wrapper for `efficient_nms` with TensorRT. + Args: + boxes (Tensor): The bounding boxes of shape [N, num_boxes, 4]. + scores (Tensor): The detection scores of shape + [N, num_boxes, num_classes]. + max_output_boxes_per_class (int): Maximum number of output + boxes per class of nms. Defaults to 1000. + iou_threshold (float): IOU threshold of nms. Defaults to 0.5. + score_threshold (float): score threshold of nms. + Defaults to 0.05. + pre_top_k (int): Number of top K boxes to keep before nms. + Defaults to -1. + keep_top_k (int): Number of top K boxes to keep after nms. + Defaults to -1. + box_coding (int): Bounding boxes format for nms. + Defaults to 0 means [x1, y1 ,x2, y2]. + Set to 1 means [x, y, w, h]. + Returns: + tuple[Tensor, Tensor, Tensor, Tensor]: + (num_det, det_boxes, det_scores, det_classes), + `num_det` of shape [N, 1] + `det_boxes` of shape [N, num_det, 4] + `det_scores` of shape [N, num_det] + `det_classes` of shape [N, num_det] + """ + num_det, det_boxes, det_scores, det_classes = TRTEfficientNMSop.apply( + boxes, scores, -1, box_coding, iou_threshold, keep_top_k, '1', 0, + score_threshold) + return num_det, det_boxes, det_scores, det_classes + + +def _batched_nms( + boxes: Tensor, + scores: Tensor, + max_output_boxes_per_class: int = 1000, + iou_threshold: float = 0.5, + score_threshold: float = 0.05, + pre_top_k: int = -1, + keep_top_k: int = 100, + box_coding: int = 0, +): + """Wrapper for `efficient_nms` with TensorRT. + Args: + boxes (Tensor): The bounding boxes of shape [N, num_boxes, 4]. + scores (Tensor): The detection scores of shape + [N, num_boxes, num_classes]. + max_output_boxes_per_class (int): Maximum number of output + boxes per class of nms. Defaults to 1000. + iou_threshold (float): IOU threshold of nms. Defaults to 0.5. + score_threshold (float): score threshold of nms. + Defaults to 0.05. + pre_top_k (int): Number of top K boxes to keep before nms. + Defaults to -1. + keep_top_k (int): Number of top K boxes to keep after nms. + Defaults to -1. + box_coding (int): Bounding boxes format for nms. + Defaults to 0 means [x1, y1 ,x2, y2]. + Set to 1 means [x, y, w, h]. + Returns: + tuple[Tensor, Tensor, Tensor, Tensor]: + (num_det, det_boxes, det_scores, det_classes), + `num_det` of shape [N, 1] + `det_boxes` of shape [N, num_det, 4] + `det_scores` of shape [N, num_det] + `det_classes` of shape [N, num_det] + """ + if box_coding == 1: + boxes = boxes @ (_XYWH2XYXY.to(boxes.device)) + boxes = boxes if boxes.dim() == 4 else boxes.unsqueeze(2) + _, _, numClasses = scores.shape + + num_det, det_boxes, det_scores, det_classes = TRTbatchedNMSop.apply( + boxes, scores, '1', 1, -1, int(numClasses), min(pre_top_k, 4096), + keep_top_k, score_threshold, iou_threshold, 0, 0, 16, 1) + + det_classes = det_classes.int() + return num_det, det_boxes, det_scores, det_classes + + +def efficient_nms(*args, **kwargs): + """Wrapper function for `_efficient_nms`.""" + return _efficient_nms(*args, **kwargs) + + +def batched_nms(*args, **kwargs): + """Wrapper function for `_batched_nms`.""" + return _batched_nms(*args, **kwargs) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/onnx_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/onnx_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/build_engine.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/build_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..b400c9db826878a7bb0fb13f4b1dea9b793583e7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/build_engine.py @@ -0,0 +1,136 @@ +import argparse +from pathlib import Path +from typing import List, Optional, Tuple, Union + +try: + import tensorrt as trt +except Exception: + trt = None +import warnings + +import numpy as np +import torch + +warnings.filterwarnings(action='ignore', category=DeprecationWarning) + + +class EngineBuilder: + + def __init__( + self, + checkpoint: Union[str, Path], + opt_shape: Union[Tuple, List] = (1, 3, 640, 640), + device: Optional[Union[str, int, torch.device]] = None) -> None: + checkpoint = Path(checkpoint) if isinstance(checkpoint, + str) else checkpoint + assert checkpoint.exists() and checkpoint.suffix == '.onnx' + if isinstance(device, str): + device = torch.device(device) + elif isinstance(device, int): + device = torch.device(f'cuda:{device}') + + self.checkpoint = checkpoint + self.opt_shape = np.array(opt_shape, dtype=np.float32) + self.device = device + + def __build_engine(self, + scale: Optional[List[List]] = None, + fp16: bool = True, + with_profiling: bool = True) -> None: + logger = trt.Logger(trt.Logger.WARNING) + trt.init_libnvinfer_plugins(logger, namespace='') + builder = trt.Builder(logger) + config = builder.create_builder_config() + config.max_workspace_size = torch.cuda.get_device_properties( + self.device).total_memory + flag = (1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) + network = builder.create_network(flag) + parser = trt.OnnxParser(network, logger) + if not parser.parse_from_file(str(self.checkpoint)): + raise RuntimeError( + f'failed to load ONNX file: {str(self.checkpoint)}') + inputs = [network.get_input(i) for i in range(network.num_inputs)] + outputs = [network.get_output(i) for i in range(network.num_outputs)] + profile = None + dshape = -1 in network.get_input(0).shape + if dshape: + profile = builder.create_optimization_profile() + if scale is None: + scale = np.array( + [[1, 1, 0.5, 0.5], [1, 1, 1, 1], [4, 1, 1.5, 1.5]], + dtype=np.float32) + scale = (self.opt_shape * scale).astype(np.int32) + elif isinstance(scale, List): + scale = np.array(scale, dtype=np.int32) + assert scale.shape[0] == 3, 'Input a wrong scale list' + else: + raise NotImplementedError + + for inp in inputs: + logger.log( + trt.Logger.WARNING, + f'input "{inp.name}" with shape{inp.shape} {inp.dtype}') + if dshape: + profile.set_shape(inp.name, *scale) + for out in outputs: + logger.log( + trt.Logger.WARNING, + f'output "{out.name}" with shape{out.shape} {out.dtype}') + if fp16 and builder.platform_has_fast_fp16: + config.set_flag(trt.BuilderFlag.FP16) + self.weight = self.checkpoint.with_suffix('.engine') + if dshape: + config.add_optimization_profile(profile) + if with_profiling: + config.profiling_verbosity = trt.ProfilingVerbosity.DETAILED + with builder.build_engine(network, config) as engine: + self.weight.write_bytes(engine.serialize()) + logger.log( + trt.Logger.WARNING, f'Build tensorrt engine finish.\n' + f'Save in {str(self.weight.absolute())}') + + def build(self, + scale: Optional[List[List]] = None, + fp16: bool = True, + with_profiling=True): + self.__build_engine(scale, fp16, with_profiling) + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--img-size', + nargs='+', + type=int, + default=[640, 640], + help='Image size of height and width') + parser.add_argument( + '--device', type=str, default='cuda:0', help='TensorRT builder device') + parser.add_argument( + '--scales', + type=str, + default='[[1,3,640,640],[1,3,640,640],[1,3,640,640]]', + help='Input scales for build dynamic input shape engine') + parser.add_argument( + '--fp16', action='store_true', help='Build model with fp16 mode') + args = parser.parse_args() + args.img_size *= 2 if len(args.img_size) == 1 else 1 + return args + + +def main(args): + img_size = (1, 3, *args.img_size) + try: + scales = eval(args.scales) + except Exception: + print('Input scales is not a python variable') + print('Set scales default None') + scales = None + builder = EngineBuilder(args.checkpoint, img_size, args.device) + builder.build(scales, fp16=args.fp16) + + +if __name__ == '__main__': + args = parse_args() + main(args) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/export_onnx.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/export_onnx.py new file mode 100644 index 0000000000000000000000000000000000000000..b937cc8a72b5c09d61580ddb1297213693adaf1c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/export_onnx.py @@ -0,0 +1,157 @@ +import argparse +import os +import sys +import warnings +from io import BytesIO +from pathlib import Path + +import onnx +import torch +from mmdet.apis import init_detector +from mmengine.config import ConfigDict +from mmengine.logging import print_log +from mmengine.utils.path import mkdir_or_exist + +# Add MMYOLO ROOT to sys.path +sys.path.append(str(Path(__file__).resolve().parents[3])) +from projects.easydeploy.model import DeployModel, MMYOLOBackend # noqa E402 + +warnings.filterwarnings(action='ignore', category=torch.jit.TracerWarning) +warnings.filterwarnings(action='ignore', category=torch.jit.ScriptWarning) +warnings.filterwarnings(action='ignore', category=UserWarning) +warnings.filterwarnings(action='ignore', category=FutureWarning) +warnings.filterwarnings(action='ignore', category=ResourceWarning) + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--model-only', action='store_true', help='Export model only') + parser.add_argument( + '--work-dir', default='./work_dir', help='Path to save export model') + parser.add_argument( + '--img-size', + nargs='+', + type=int, + default=[640, 640], + help='Image size of height and width') + parser.add_argument('--batch-size', type=int, default=1, help='Batch size') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--simplify', + action='store_true', + help='Simplify onnx model by onnx-sim') + parser.add_argument( + '--opset', type=int, default=11, help='ONNX opset version') + parser.add_argument( + '--backend', + type=str, + default='onnxruntime', + help='Backend for export onnx') + parser.add_argument( + '--pre-topk', + type=int, + default=1000, + help='Postprocess pre topk bboxes feed into NMS') + parser.add_argument( + '--keep-topk', + type=int, + default=100, + help='Postprocess keep topk bboxes out of NMS') + parser.add_argument( + '--iou-threshold', + type=float, + default=0.65, + help='IoU threshold for NMS') + parser.add_argument( + '--score-threshold', + type=float, + default=0.25, + help='Score threshold for NMS') + args = parser.parse_args() + args.img_size *= 2 if len(args.img_size) == 1 else 1 + return args + + +def build_model_from_cfg(config_path, checkpoint_path, device): + model = init_detector(config_path, checkpoint_path, device=device) + model.eval() + return model + + +def main(): + args = parse_args() + mkdir_or_exist(args.work_dir) + backend = MMYOLOBackend(args.backend.lower()) + if backend in (MMYOLOBackend.ONNXRUNTIME, MMYOLOBackend.OPENVINO, + MMYOLOBackend.TENSORRT8, MMYOLOBackend.TENSORRT7): + if not args.model_only: + print_log('Export ONNX with bbox decoder and NMS ...') + else: + args.model_only = True + print_log(f'Can not export postprocess for {args.backend.lower()}.\n' + f'Set "args.model_only=True" default.') + if args.model_only: + postprocess_cfg = None + output_names = None + else: + postprocess_cfg = ConfigDict( + pre_top_k=args.pre_topk, + keep_top_k=args.keep_topk, + iou_threshold=args.iou_threshold, + score_threshold=args.score_threshold) + output_names = ['num_dets', 'boxes', 'scores', 'labels'] + baseModel = build_model_from_cfg(args.config, args.checkpoint, args.device) + + deploy_model = DeployModel( + baseModel=baseModel, backend=backend, postprocess_cfg=postprocess_cfg) + deploy_model.eval() + + fake_input = torch.randn(args.batch_size, 3, + *args.img_size).to(args.device) + # dry run + deploy_model(fake_input) + + save_onnx_path = os.path.join( + args.work_dir, + os.path.basename(args.checkpoint).replace('pth', 'onnx')) + # export onnx + with BytesIO() as f: + torch.onnx.export( + deploy_model, + fake_input, + f, + input_names=['images'], + output_names=output_names, + opset_version=args.opset) + f.seek(0) + onnx_model = onnx.load(f) + onnx.checker.check_model(onnx_model) + + # Fix tensorrt onnx output shape, just for view + if not args.model_only and backend in (MMYOLOBackend.TENSORRT8, + MMYOLOBackend.TENSORRT7): + shapes = [ + args.batch_size, 1, args.batch_size, args.keep_topk, 4, + args.batch_size, args.keep_topk, args.batch_size, + args.keep_topk + ] + for i in onnx_model.graph.output: + for j in i.type.tensor_type.shape.dim: + j.dim_param = str(shapes.pop(0)) + if args.simplify: + try: + import onnxsim + onnx_model, check = onnxsim.simplify(onnx_model) + assert check, 'assert check failed' + except Exception as e: + print_log(f'Simplify failure: {e}') + onnx.save(onnx_model, save_onnx_path) + print_log(f'ONNX export success, save into {save_onnx_path}') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/image-demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/image-demo.py new file mode 100644 index 0000000000000000000000000000000000000000..12ebaddce60b30021fea6a2f512cb8248db45a8e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/easydeploy/tools/image-demo.py @@ -0,0 +1,152 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from easydeploy.model import ORTWrapper, TRTWrapper # isort:skip +import os +import random +from argparse import ArgumentParser + +import cv2 +import mmcv +import numpy as np +import torch +from mmcv.transforms import Compose +from mmdet.utils import get_test_pipeline_cfg +from mmengine.config import Config, ConfigDict +from mmengine.utils import ProgressBar, path + +from mmyolo.utils import register_all_modules +from mmyolo.utils.misc import get_file_list + + +def parse_args(): + parser = ArgumentParser() + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--out-dir', default='./output', help='Path to output file') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--show', action='store_true', help='Show the detection results') + args = parser.parse_args() + return args + + +def preprocess(config): + data_preprocess = config.get('model', {}).get('data_preprocessor', {}) + mean = data_preprocess.get('mean', [0., 0., 0.]) + std = data_preprocess.get('std', [1., 1., 1.]) + mean = torch.tensor(mean, dtype=torch.float32).reshape(1, 3, 1, 1) + std = torch.tensor(std, dtype=torch.float32).reshape(1, 3, 1, 1) + + class PreProcess(torch.nn.Module): + + def __init__(self): + super().__init__() + + def forward(self, x): + x = x[None].float() + x -= mean.to(x.device) + x /= std.to(x.device) + return x + + return PreProcess().eval() + + +def main(): + args = parse_args() + + # register all modules in mmdet into the registries + register_all_modules() + + colors = [[random.randint(0, 255) for _ in range(3)] for _ in range(1000)] + + # build the model from a config file and a checkpoint file + if args.checkpoint.endswith('.onnx'): + model = ORTWrapper(args.checkpoint, args.device) + elif args.checkpoint.endswith('.engine') or args.checkpoint.endswith( + '.plan'): + model = TRTWrapper(args.checkpoint, args.device) + else: + raise NotImplementedError + + model.to(args.device) + + cfg = Config.fromfile(args.config) + class_names = cfg.get('class_name') + + test_pipeline = get_test_pipeline_cfg(cfg) + test_pipeline[0] = ConfigDict({'type': 'mmdet.LoadImageFromNDArray'}) + test_pipeline = Compose(test_pipeline) + + pre_pipeline = preprocess(cfg) + + if not args.show: + path.mkdir_or_exist(args.out_dir) + + # get file list + files, source_type = get_file_list(args.img) + + # start detector inference + progress_bar = ProgressBar(len(files)) + for i, file in enumerate(files): + bgr = mmcv.imread(file) + rgb = mmcv.imconvert(bgr, 'bgr', 'rgb') + data, samples = test_pipeline(dict(img=rgb, img_id=i)).values() + pad_param = samples.get('pad_param', + np.array([0, 0, 0, 0], dtype=np.float32)) + h, w = samples.get('ori_shape', rgb.shape[:2]) + pad_param = torch.asarray( + [pad_param[2], pad_param[0], pad_param[2], pad_param[0]], + device=args.device) + scale_factor = samples.get('scale_factor', [1., 1]) + scale_factor = torch.asarray(scale_factor * 2, device=args.device) + data = pre_pipeline(data).to(args.device) + + result = model(data) + if source_type['is_dir']: + filename = os.path.relpath(file, args.img).replace('/', '_') + else: + filename = os.path.basename(file) + out_file = None if args.show else os.path.join(args.out_dir, filename) + + # Get candidate predict info by num_dets + num_dets, bboxes, scores, labels = result + scores = scores[0, :num_dets] + bboxes = bboxes[0, :num_dets] + labels = labels[0, :num_dets] + bboxes -= pad_param + bboxes /= scale_factor + + bboxes[:, 0::2].clamp_(0, w) + bboxes[:, 1::2].clamp_(0, h) + bboxes = bboxes.round().int() + + for (bbox, score, label) in zip(bboxes, scores, labels): + bbox = bbox.tolist() + color = colors[label] + + if class_names is not None: + label_name = class_names[label] + name = f'cls:{label_name}_score:{score:0.4f}' + else: + name = f'cls:{label}_score:{score:0.4f}' + + cv2.rectangle(bgr, bbox[:2], bbox[2:], color, 2) + cv2.putText( + bgr, + name, (bbox[0], bbox[1] - 2), + cv2.FONT_HERSHEY_SIMPLEX, + 2.0, [225, 255, 255], + thickness=3) + + if args.show: + mmcv.imshow(bgr, 'result', 0) + else: + mmcv.imwrite(bgr, out_file) + progress_bar.update() + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/export_onnx.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/export_onnx.py new file mode 100644 index 0000000000000000000000000000000000000000..4041b12112ae96d5410177c51f08fcd28ad3bb48 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/export_onnx.py @@ -0,0 +1,182 @@ +# # Copyright (c) OpenMMLab. All rights reserved. +import os +import json +import warnings +import argparse +from io import BytesIO + +import onnx +import torch +from mmdet.apis import init_detector +from mmengine.config import ConfigDict +from mmengine.logging import print_log +from mmengine.utils.path import mkdir_or_exist + +from easydeploy.model import DeployModel, MMYOLOBackend # noqa E402 + +warnings.filterwarnings(action='ignore', category=torch.jit.TracerWarning) +warnings.filterwarnings(action='ignore', category=torch.jit.ScriptWarning) +warnings.filterwarnings(action='ignore', category=UserWarning) +warnings.filterwarnings(action='ignore', category=FutureWarning) +warnings.filterwarnings(action='ignore', category=ResourceWarning) + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument('--custom-text', + type=str, + help='custom text inputs (text json) for YOLO-World.') + parser.add_argument('--add-padding', + action="store_true", + help="add an empty padding to texts.") + parser.add_argument('--model-only', + action='store_true', + help='Export model only') + parser.add_argument('--without-nms', + action='store_true', + help='Export model without NMS') + parser.add_argument('--without-bbox-decoder', + action='store_true', + help='Export model without Bbox Decoder (for INT8 Quantization)') + parser.add_argument('--work-dir', + default='./work_dirs', + help='Path to save export model') + parser.add_argument('--img-size', + nargs='+', + type=int, + default=[640, 640], + help='Image size of height and width') + parser.add_argument('--batch-size', type=int, default=1, help='Batch size') + parser.add_argument('--device', + default='cuda:0', + help='Device used for inference') + parser.add_argument('--simplify', + action='store_true', + help='Simplify onnx model by onnx-sim') + parser.add_argument('--opset', + type=int, + default=11, + help='ONNX opset version') + parser.add_argument('--backend', + type=str, + default='onnxruntime', + help='Backend for export onnx') + parser.add_argument('--pre-topk', + type=int, + default=1000, + help='Postprocess pre topk bboxes feed into NMS') + parser.add_argument('--keep-topk', + type=int, + default=100, + help='Postprocess keep topk bboxes out of NMS') + parser.add_argument('--iou-threshold', + type=float, + default=0.65, + help='IoU threshold for NMS') + parser.add_argument('--score-threshold', + type=float, + default=0.25, + help='Score threshold for NMS') + args = parser.parse_args() + args.img_size *= 2 if len(args.img_size) == 1 else 1 + return args + + +def build_model_from_cfg(config_path, checkpoint_path, device): + model = init_detector(config_path, checkpoint_path, device=device) + model.eval() + return model + + +def main(): + args = parse_args() + mkdir_or_exist(args.work_dir) + backend = MMYOLOBackend(args.backend.lower()) + if backend in (MMYOLOBackend.ONNXRUNTIME, MMYOLOBackend.OPENVINO, + MMYOLOBackend.TENSORRT8, MMYOLOBackend.TENSORRT7): + if not args.model_only: + print_log('Export ONNX with bbox decoder and NMS ...') + else: + args.model_only = True + print_log(f'Can not export postprocess for {args.backend.lower()}.\n' + f'Set "args.model_only=True" default.') + if args.model_only: + postprocess_cfg = None + output_names = None + else: + postprocess_cfg = ConfigDict(pre_top_k=args.pre_topk, + keep_top_k=args.keep_topk, + iou_threshold=args.iou_threshold, + score_threshold=args.score_threshold) + + output_names = ['num_dets', 'boxes', 'scores', 'labels'] + if args.without_bbox_decoder or args.without_nms: + output_names = ['scores', 'boxes'] + + if args.custom_text is not None and len(args.custom_text) > 0: + with open(args.custom_text) as f: + texts = json.load(f) + texts = [x[0] for x in texts] + else: + from mmdet.datasets import CocoDataset + texts = CocoDataset.METAINFO['classes'] + if args.add_padding: + texts = texts + [' '] + + baseModel = build_model_from_cfg(args.config, args.checkpoint, args.device) + if hasattr(baseModel, 'reparameterize'): + # reparameterize text into YOLO-World + baseModel.reparameterize([texts]) + deploy_model = DeployModel(baseModel=baseModel, + backend=backend, + postprocess_cfg=postprocess_cfg, + with_nms=not args.without_nms, + without_bbox_decoder=args.without_bbox_decoder) + deploy_model.eval() + + fake_input = torch.randn(args.batch_size, 3, + *args.img_size).to(args.device) + # dry run + deploy_model(fake_input) + + save_onnx_path = os.path.join( + args.work_dir, + os.path.basename(args.checkpoint).replace('pth', 'onnx')) + # export onnx + with BytesIO() as f: + torch.onnx.export(deploy_model, + fake_input, + f, + input_names=['images'], + output_names=output_names, + opset_version=args.opset) + f.seek(0) + onnx_model = onnx.load(f) + onnx.checker.check_model(onnx_model) + + # Fix tensorrt onnx output shape, just for view + if not args.model_only and not args.without_nms and backend in ( + MMYOLOBackend.TENSORRT8, MMYOLOBackend.TENSORRT7): + shapes = [ + args.batch_size, 1, args.batch_size, args.keep_topk, 4, + args.batch_size, args.keep_topk, args.batch_size, + args.keep_topk + ] + for i in onnx_model.graph.output: + for j in i.type.tensor_type.shape.dim: + j.dim_param = str(shapes.pop(0)) + if args.simplify: + try: + import onnxsim + onnx_model, check = onnxsim.simplify(onnx_model) + assert check, 'assert check failed' + except Exception as e: + print_log(f'Simplify failure: {e}') + onnx.save(onnx_model, save_onnx_path) + print_log(f'ONNX export success, save into {save_onnx_path}') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/onnx_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/onnx_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..35f2713ecd695a18c47837d3036022983f75a254 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/onnx_demo.py @@ -0,0 +1,235 @@ +import os +import json +import argparse +import os.path as osp + +import cv2 +import numpy as np +import supervision as sv +import onnxruntime as ort +from mmengine.utils import ProgressBar + +try: + import torch + from torchvision.ops import nms +except Exception as e: + print(e) + +BOUNDING_BOX_ANNOTATOR = sv.BoundingBoxAnnotator(thickness=1) +MASK_ANNOTATOR = sv.MaskAnnotator() + + +class LabelAnnotator(sv.LabelAnnotator): + + @staticmethod + def resolve_text_background_xyxy( + center_coordinates, + text_wh, + position, + ): + center_x, center_y = center_coordinates + text_w, text_h = text_wh + return center_x, center_y, center_x + text_w, center_y + text_h + + +LABEL_ANNOTATOR = LabelAnnotator(text_padding=4, + text_scale=0.5, + text_thickness=1) + + +def parse_args(): + parser = argparse.ArgumentParser('YOLO-World ONNX Demo') + parser.add_argument('onnx', help='onnx file') + parser.add_argument('image', help='image path, include image file or dir.') + parser.add_argument( + 'text', + help= + 'detecting texts (str or json), should be consistent with the ONNX model' + ) + parser.add_argument('--output-dir', + default='./output', + help='directory to save output files') + parser.add_argument('--device', + default='cuda:0', + help='device used for inference') + parser.add_argument( + '--onnx-nms', + action='store_false', + help='whether ONNX model contains NMS and postprocessing') + args = parser.parse_args() + return args + + +def preprocess(image, size=(640, 640)): + h, w = image.shape[:2] + max_size = max(h, w) + scale_factor = size[0] / max_size + pad_h = (max_size - h) // 2 + pad_w = (max_size - w) // 2 + pad_image = np.zeros((max_size, max_size, 3), dtype=image.dtype) + pad_image[pad_h:h + pad_h, pad_w:w + pad_w] = image + image = cv2.resize(pad_image, size, + interpolation=cv2.INTER_LINEAR).astype('float32') + image /= 255.0 + image = image[None] + return image, scale_factor, (pad_h, pad_w) + + +def visualize(image, bboxes, labels, scores, texts): + detections = sv.Detections(xyxy=bboxes, class_id=labels, confidence=scores) + labels = [ + f"{texts[class_id][0]} {confidence:0.2f}" for class_id, confidence in + zip(detections.class_id, detections.confidence) + ] + + image = BOUNDING_BOX_ANNOTATOR.annotate(image, detections) + image = LABEL_ANNOTATOR.annotate(image, detections, labels=labels) + return image + + +def inference(ort_session, + image_path, + texts, + output_dir, + size=(640, 640), + **kwargs): + # normal export + # with NMS and postprocessing + ori_image = cv2.imread(image_path) + h, w = ori_image.shape[:2] + image, scale_factor, pad_param = preprocess(ori_image[:, :, [2, 1, 0]], + size) + input_ort = ort.OrtValue.ortvalue_from_numpy(image.transpose((0, 3, 1, 2))) + results = ort_session.run(["num_dets", "labels", "scores", "boxes"], + {"images": input_ort}) + num_dets, labels, scores, bboxes = results + num_dets = num_dets[0][0] + labels = labels[0, :num_dets] + scores = scores[0, :num_dets] + bboxes = bboxes[0, :num_dets] + + bboxes -= np.array( + [pad_param[1], pad_param[0], pad_param[1], pad_param[0]]) + bboxes /= scale_factor + bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, w) + bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, h) + bboxes = bboxes.round().astype('int') + + image_out = visualize(ori_image, bboxes, labels, scores, texts) + cv2.imwrite(osp.join(output_dir, osp.basename(image_path)), image_out) + return image_out + + +def inference_with_postprocessing(ort_session, + image_path, + texts, + output_dir, + size=(640, 640), + nms_thr=0.7, + score_thr=0.3, + max_dets=300): + # export with `--without-nms` + ori_image = cv2.imread(image_path) + h, w = ori_image.shape[:2] + image, scale_factor, pad_param = preprocess(ori_image[:, :, [2, 1, 0]], + size) + input_ort = ort.OrtValue.ortvalue_from_numpy(image.transpose((0, 3, 1, 2))) + results = ort_session.run(["scores", "boxes"], {"images": input_ort}) + scores, bboxes = results + # move numpy array to torch + ori_scores = torch.from_numpy(scores[0]).to('cuda:0') + ori_bboxes = torch.from_numpy(bboxes[0]).to('cuda:0') + + scores_list = [] + labels_list = [] + bboxes_list = [] + # class-specific NMS + for cls_id in range(len(texts)): + cls_scores = ori_scores[:, cls_id] + labels = torch.ones(cls_scores.shape[0], dtype=torch.long) * cls_id + keep_idxs = nms(ori_bboxes, cls_scores, iou_threshold=nms_thr) + cur_bboxes = ori_bboxes[keep_idxs] + cls_scores = cls_scores[keep_idxs] + labels = labels[keep_idxs] + scores_list.append(cls_scores) + labels_list.append(labels) + bboxes_list.append(cur_bboxes) + + scores = torch.cat(scores_list, dim=0) + labels = torch.cat(labels_list, dim=0) + bboxes = torch.cat(bboxes_list, dim=0) + + keep_idxs = scores > score_thr + scores = scores[keep_idxs] + labels = labels[keep_idxs] + bboxes = bboxes[keep_idxs] + if len(keep_idxs) > max_dets: + _, sorted_idx = torch.sort(scores, descending=True) + keep_idxs = sorted_idx[:max_dets] + bboxes = bboxes[keep_idxs] + scores = scores[keep_idxs] + labels = labels[keep_idxs] + + # Get candidate predict info by num_dets + scores = scores.cpu().numpy() + bboxes = bboxes.cpu().numpy() + labels = labels.cpu().numpy() + + bboxes -= np.array( + [pad_param[1], pad_param[0], pad_param[1], pad_param[0]]) + bboxes /= scale_factor + bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, w) + bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, h) + bboxes = bboxes.round().astype('int') + + image_out = visualize(ori_image, bboxes, labels, scores, texts) + cv2.imwrite(osp.join(output_dir, osp.basename(image_path)), image_out) + return image_out + + +def main(): + + args = parse_args() + onnx_file = args.onnx + # init ONNX session + ort_session = ort.InferenceSession( + onnx_file, providers=['CUDAExecutionProvider', 'CPUExecutionProvider']) + print("Init ONNX Runtime session") + output_dir = "onnx_outputs" + if not osp.exists(output_dir): + os.mkdir(output_dir) + + # load images + if not osp.isfile(args.image): + images = [ + osp.join(args.image, img) for img in os.listdir(args.image) + if img.endswith('.png') or img.endswith('.jpg') + ] + else: + images = [args.image] + + if args.text.endswith('.txt'): + with open(args.text) as f: + lines = f.readlines() + texts = [[t.rstrip('\r\n')] for t in lines] + elif args.text.endswith('.json'): + texts = json.load(open(args.text)) + else: + texts = [[t.strip()] for t in args.text.split(',')] + + print("Start to inference.") + progress_bar = ProgressBar(len(images)) + + if args.onnx_nms: + inference_func = inference + else: + inference_func = inference_with_postprocessing + + for img in images: + inference_func(ort_session, img, texts, output_dir=output_dir) + progress_bar.update() + print("Finish inference") + + +if __name__ == "__main__": + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/tflite_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/tflite_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..ae5bf1a7013d07eef032917391bfa20caede8395 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/deploy/tflite_demo.py @@ -0,0 +1,254 @@ +import os +import json +import argparse +import os.path as osp + +import cv2 +import tqdm +import torch +import numpy as np +import tensorflow as tf +import supervision as sv +from torchvision.ops import nms + +BOUNDING_BOX_ANNOTATOR = sv.BoundingBoxAnnotator(thickness=1) +MASK_ANNOTATOR = sv.MaskAnnotator() + + +class LabelAnnotator(sv.LabelAnnotator): + + @staticmethod + def resolve_text_background_xyxy( + center_coordinates, + text_wh, + position, + ): + center_x, center_y = center_coordinates + text_w, text_h = text_wh + return center_x, center_y, center_x + text_w, center_y + text_h + + +LABEL_ANNOTATOR = LabelAnnotator(text_padding=4, + text_scale=0.5, + text_thickness=1) + + +def parse_args(): + parser = argparse.ArgumentParser('YOLO-World TFLite (INT8) Demo') + parser.add_argument('path', help='TFLite Model `.tflite`') + parser.add_argument('image', help='image path, include image file or dir.') + parser.add_argument( + 'text', + help= + 'detecting texts (str, txt, or json), should be consistent with the ONNX model' + ) + parser.add_argument('--output-dir', + default='./output', + help='directory to save output files') + args = parser.parse_args() + return args + + +def preprocess(image, size=(640, 640)): + h, w = image.shape[:2] + max_size = max(h, w) + scale_factor = size[0] / max_size + pad_h = (max_size - h) // 2 + pad_w = (max_size - w) // 2 + pad_image = np.zeros((max_size, max_size, 3), dtype=image.dtype) + pad_image[pad_h:h + pad_h, pad_w:w + pad_w] = image + image = cv2.resize(pad_image, size, + interpolation=cv2.INTER_LINEAR).astype('float32') + image /= 255.0 + image = image[None] + return image, scale_factor, (pad_h, pad_w) + + +def generate_anchors_per_level(feat_size, stride, offset=0.5): + h, w = feat_size + shift_x = (torch.arange(0, w) + offset) * stride + shift_y = (torch.arange(0, h) + offset) * stride + yy, xx = torch.meshgrid(shift_y, shift_x) + anchors = torch.stack([xx, yy]).reshape(2, -1).transpose(0, 1) + return anchors + + +def generate_anchors(feat_sizes=[(80, 80), (40, 40), (20, 20)], + strides=[8, 16, 32], + offset=0.5): + anchors = [ + generate_anchors_per_level(fs, s, offset) + for fs, s in zip(feat_sizes, strides) + ] + anchors = torch.cat(anchors) + return anchors + + +def simple_bbox_decode(points, pred_bboxes, stride): + + pred_bboxes = pred_bboxes * stride[None, :, None] + x1 = points[..., 0] - pred_bboxes[..., 0] + y1 = points[..., 1] - pred_bboxes[..., 1] + x2 = points[..., 0] + pred_bboxes[..., 2] + y2 = points[..., 1] + pred_bboxes[..., 3] + bboxes = torch.stack([x1, y1, x2, y2], -1) + + return bboxes + + +def visualize(image, bboxes, labels, scores, texts): + detections = sv.Detections(xyxy=bboxes, class_id=labels, confidence=scores) + labels = [ + f"{texts[class_id][0]} {confidence:0.2f}" for class_id, confidence in + zip(detections.class_id, detections.confidence) + ] + + image = BOUNDING_BOX_ANNOTATOR.annotate(image, detections) + image = LABEL_ANNOTATOR.annotate(image, detections, labels=labels) + return image + + +def inference_per_sample(interp, + image_path, + texts, + priors, + strides, + output_dir, + size=(640, 640), + vis=False, + score_thr=0.05, + nms_thr=0.3, + max_dets=300): + + # input / output details from TFLite + input_details = interp.get_input_details() + output_details = interp.get_output_details() + + # load image from path + ori_image = cv2.imread(image_path) + h, w = ori_image.shape[:2] + image, scale_factor, pad_param = preprocess(ori_image[:, :, [2, 1, 0]], + size) + + # inference + interp.set_tensor(input_details[0]['index'], image) + interp.invoke() + + scores = interp.get_tensor(output_details[1]['index']) + bboxes = interp.get_tensor(output_details[0]['index']) + + # can be converted to numpy for other devices + # using torch here is only for references. + ori_scores = torch.from_numpy(scores[0]) + ori_bboxes = torch.from_numpy(bboxes) + + # decode bbox cordinates with priors + decoded_bboxes = simple_bbox_decode(priors, ori_bboxes, strides)[0] + scores_list = [] + labels_list = [] + bboxes_list = [] + for cls_id in range(len(texts)): + cls_scores = ori_scores[:, cls_id] + labels = torch.ones(cls_scores.shape[0], dtype=torch.long) * cls_id + keep_idxs = nms(decoded_bboxes, cls_scores, iou_threshold=0.5) + cur_bboxes = decoded_bboxes[keep_idxs] + cls_scores = cls_scores[keep_idxs] + labels = labels[keep_idxs] + scores_list.append(cls_scores) + labels_list.append(labels) + bboxes_list.append(cur_bboxes) + + scores = torch.cat(scores_list, dim=0) + labels = torch.cat(labels_list, dim=0) + bboxes = torch.cat(bboxes_list, dim=0) + + keep_idxs = scores > score_thr + scores = scores[keep_idxs] + labels = labels[keep_idxs] + bboxes = bboxes[keep_idxs] + # only for visualization, add an extra NMS + keep_idxs = nms(bboxes, scores, iou_threshold=nms_thr) + num_dets = min(len(keep_idxs), max_dets) + bboxes = bboxes[keep_idxs].unsqueeze(0) + scores = scores[keep_idxs].unsqueeze(0) + labels = labels[keep_idxs].unsqueeze(0) + + scores = scores[0, :num_dets].numpy() + bboxes = bboxes[0, :num_dets].numpy() + labels = labels[0, :num_dets].numpy() + + bboxes -= np.array( + [pad_param[1], pad_param[0], pad_param[1], pad_param[0]]) + bboxes /= scale_factor + bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, w) + bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, h) + + if vis: + image_out = visualize(ori_image, bboxes, labels, scores, texts) + cv2.imwrite(osp.join(output_dir, osp.basename(image_path)), image_out) + print(f"detecting {num_dets} objects.") + return image_out, ori_scores, ori_bboxes[0] + else: + return bboxes, labels, scores + + +def main(): + + args = parse_args() + tflite_file = args.tflite + # init ONNX session + interpreter = tf.lite.Interpreter(model_path=tflite_file, + experimental_preserve_all_tensors=True) + interpreter.allocate_tensors() + print("Init TFLite Interpter") + output_dir = "onnx_outputs" + if not osp.exists(output_dir): + os.mkdir(output_dir) + + # load images + if not osp.isfile(args.image): + images = [ + osp.join(args.image, img) for img in os.listdir(args.image) + if img.endswith('.png') or img.endswith('.jpg') + ] + else: + images = [args.image] + + if args.text.endswith('.txt'): + with open(args.text) as f: + lines = f.readlines() + texts = [[t.rstrip('\r\n')] for t in lines] + elif args.text.endswith('.json'): + texts = json.load(open(args.text)) + else: + texts = [[t.strip()] for t in args.text.split(',')] + + size = (640, 640) + strides = [8, 16, 32] + + # prepare anchors, since TFLite models does not contain anchors, due to INT8 quantization. + featmap_sizes = [(size[0] // s, size[1] // s) for s in strides] + flatten_priors = generate_anchors(featmap_sizes, strides=strides) + mlvl_strides = [ + flatten_priors.new_full((featmap_size[0] * featmap_size[1] * 1, ), + stride) + for featmap_size, stride in zip(featmap_sizes, strides) + ] + flatten_strides = torch.cat(mlvl_strides) + + print("Start to inference.") + for img in tqdm.tqdm(images): + inference_per_sample(interpreter, + img, + texts, + flatten_priors[None], + flatten_strides, + output_dir=output_dir, + vis=True, + score_thr=0.3, + nms_thr=0.5) + print("Finish inference") + + +if __name__ == "__main__": + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/config.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/config.yml new file mode 100644 index 0000000000000000000000000000000000000000..59ba321aeec5dd3904c8df29e2833a41dbc676f7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/config.yml @@ -0,0 +1,34 @@ +version: 2.1 + +# this allows you to use CircleCI's dynamic configuration feature +setup: true + +# the path-filtering orb is required to continue a pipeline based on +# the path of an updated fileset +orbs: + path-filtering: circleci/path-filtering@0.1.2 + +workflows: + # the always-run workflow is always triggered, regardless of the pipeline parameters. + always-run: + jobs: + # the path-filtering/filter job determines which pipeline + # parameters to update. + - path-filtering/filter: + name: check-updated-files + # 3-column, whitespace-delimited mapping. One mapping per + # line: + # + mapping: | + mmyolo/.* lint_only false + requirements/.* lint_only false + tests/.* lint_only false + tools/.* lint_only false + configs/.* lint_only false + .circleci/.* lint_only false + base-revision: main + # this is the path of the configuration we should trigger once + # path filtering and pipeline parameter value updates are + # complete. In this case, we are using the parent dynamic + # configuration itself. + config-path: .circleci/test.yml diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/docker/Dockerfile b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/docker/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..d9cf8cc7712d5241975c3b748fb0d01a5545b4fd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/docker/Dockerfile @@ -0,0 +1,11 @@ +ARG PYTORCH="1.8.1" +ARG CUDA="10.2" +ARG CUDNN="7" + +FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel + +# To fix GPG key error when running apt-get update +RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub +RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub + +RUN apt-get update && apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/test.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/test.yml new file mode 100644 index 0000000000000000000000000000000000000000..149d6cac15ff9643a21535638a6cd5f961a17d4a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.circleci/test.yml @@ -0,0 +1,213 @@ +version: 2.1 + +# the default pipeline parameters, which will be updated according to +# the results of the path-filtering orb +parameters: + lint_only: + type: boolean + default: true + +jobs: + lint: + docker: + - image: cimg/python:3.7.4 + steps: + - checkout + - run: + name: Install pre-commit hook + command: | + pip install pre-commit + pre-commit install + - run: + name: Linting + command: pre-commit run --all-files + - run: + name: Check docstring coverage + command: | + pip install interrogate + interrogate -v --ignore-init-method --ignore-module --ignore-nested-functions --ignore-magic --ignore-regex "__repr__" --fail-under 90 mmyolo + build_cpu: + parameters: + # The python version must match available image tags in + # https://circleci.com/developer/images/image/cimg/python + python: + type: string + torch: + type: string + torchvision: + type: string + docker: + - image: cimg/python:<< parameters.python >> + resource_class: large + steps: + - checkout + - run: + name: Install Libraries + command: | + sudo apt-get update + sudo apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx libjpeg-dev zlib1g-dev libtinfo-dev libncurses5 + - run: + name: Configure Python & pip + command: | + pip install --upgrade pip + pip install wheel + - run: + name: Install PyTorch + command: | + python -V + pip install torch==<< parameters.torch >>+cpu torchvision==<< parameters.torchvision >>+cpu -f https://download.pytorch.org/whl/torch_stable.html + - run: + name: Install ONNXRuntime + command: | + pip install onnxruntime==1.8.1 + wget https://github.com/microsoft/onnxruntime/releases/download/v1.8.1/onnxruntime-linux-x64-1.8.1.tgz + tar xvf onnxruntime-linux-x64-1.8.1.tgz + - run: + name: Install mmyolo dependencies + command: | + pip install -U openmim + mim install git+https://github.com/open-mmlab/mmengine.git@main + mim install 'mmcv >= 2.0.0' + mim install git+https://github.com/open-mmlab/mmdetection.git@dev-3.x + pip install -r requirements/albu.txt + pip install -r requirements/tests.txt + - run: + name: Install mmdeploy + command: | + pip install setuptools + git clone -b dev-1.x --depth 1 https://github.com/open-mmlab/mmdeploy.git mmdeploy --recurse-submodules + wget https://github.com/Kitware/CMake/releases/download/v3.20.0/cmake-3.20.0-linux-x86_64.tar.gz + tar -xzvf cmake-3.20.0-linux-x86_64.tar.gz + sudo ln -sf $(pwd)/cmake-3.20.0-linux-x86_64/bin/* /usr/bin/ + cd mmdeploy && mkdir build && cd build && cmake .. -DMMDEPLOY_TARGET_BACKENDS=ort -DONNXRUNTIME_DIR=/home/circleci/project/onnxruntime-linux-x64-1.8.1 && make -j8 && make install + export LD_LIBRARY_PATH=/home/circleci/project/onnxruntime-linux-x64-1.8.1/lib:${LD_LIBRARY_PATH} + cd /home/circleci/project/mmdeploy && python -m pip install -v -e . + - run: + name: Build and install + command: | + pip install -e . + - run: + name: Run unittests + command: | + export LD_LIBRARY_PATH=/home/circleci/project/onnxruntime-linux-x64-1.8.1/lib:${LD_LIBRARY_PATH} + pytest tests/ +# coverage run --branch --source mmyolo -m pytest tests/ +# coverage xml +# coverage report -m + build_cuda: + parameters: + torch: + type: string + cuda: + type: enum + enum: ["10.1", "10.2", "11.0", "11.7"] + cudnn: + type: integer + default: 7 + machine: + image: ubuntu-2004-cuda-11.4:202110-01 + # docker_layer_caching: true + resource_class: gpu.nvidia.small + steps: + - checkout + - run: + # Cloning repos in VM since Docker doesn't have access to the private key + name: Clone Repos + command: | + git clone -b main --depth 1 https://github.com/open-mmlab/mmengine.git /home/circleci/mmengine + git clone -b dev-3.x --depth 1 https://github.com/open-mmlab/mmdetection.git /home/circleci/mmdetection + - run: + name: Build Docker image + command: | + docker build .circleci/docker -t mmyolo:gpu --build-arg PYTORCH=<< parameters.torch >> --build-arg CUDA=<< parameters.cuda >> --build-arg CUDNN=<< parameters.cudnn >> + docker run --gpus all -t -d -v /home/circleci/project:/mmyolo -v /home/circleci/mmengine:/mmengine -v /home/circleci/mmdetection:/mmdetection -w /mmyolo --name mmyolo mmyolo:gpu + - run: + name: Install mmyolo dependencies + command: | + docker exec mmyolo pip install -U openmim + docker exec mmyolo mim install -e /mmengine + docker exec mmyolo mim install 'mmcv >= 2.0.0' + docker exec mmyolo pip install -e /mmdetection + docker exec mmyolo pip install -r requirements/albu.txt + docker exec mmyolo pip install -r requirements/tests.txt + - run: + name: Build and install + command: | + docker exec mmyolo pip install -e . + - run: + name: Run unittests + command: | + docker exec mmyolo pytest tests/ + +workflows: + pr_stage_lint: + when: << pipeline.parameters.lint_only >> + jobs: + - lint: + name: lint + filters: + branches: + ignore: + - main + + pr_stage_test: + when: + not: << pipeline.parameters.lint_only >> + jobs: + - lint: + name: lint + filters: + branches: + ignore: + - main + - build_cpu: + name: minimum_version_cpu + torch: 1.8.0 + torchvision: 0.9.0 + python: 3.8.0 # The lowest python 3.7.x version available on CircleCI images + requires: + - lint + - build_cpu: + name: maximum_version_cpu + # mmdeploy not supported +# torch: 2.0.0 +# torchvision: 0.15.1 + torch: 1.12.1 + torchvision: 0.13.1 + python: 3.9.0 + requires: + - minimum_version_cpu + - hold: + type: approval + requires: + - maximum_version_cpu + - build_cuda: + name: mainstream_version_gpu + torch: 1.8.1 + # Use double quotation mark to explicitly specify its type + # as string instead of number + cuda: "10.2" + requires: + - hold + - build_cuda: + name: maximum_version_gpu + torch: 2.0.0 + cuda: "11.7" + cudnn: 8 + requires: + - hold + merge_stage_test: + when: + not: << pipeline.parameters.lint_only >> + jobs: + - build_cuda: + name: minimum_version_gpu + torch: 1.7.0 + # Use double quotation mark to explicitly specify its type + # as string instead of number + cuda: "11.0" + cudnn: 8 + filters: + branches: + only: + - main diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.dev_scripts/gather_models.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.dev_scripts/gather_models.py new file mode 100644 index 0000000000000000000000000000000000000000..f05e2b5b31329e12f1bd62196de6592fade0a7c8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.dev_scripts/gather_models.py @@ -0,0 +1,312 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import glob +import os +import os.path as osp +import shutil +import subprocess +import time +from collections import OrderedDict + +import torch +import yaml +from mmengine.config import Config +from mmengine.fileio import dump +from mmengine.utils import mkdir_or_exist, scandir + + +def ordered_yaml_dump(data, stream=None, Dumper=yaml.SafeDumper, **kwds): + + class OrderedDumper(Dumper): + pass + + def _dict_representer(dumper, data): + return dumper.represent_mapping( + yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, data.items()) + + OrderedDumper.add_representer(OrderedDict, _dict_representer) + return yaml.dump(data, stream, OrderedDumper, **kwds) + + +def process_checkpoint(in_file, out_file): + checkpoint = torch.load(in_file, map_location='cpu') + # remove optimizer for smaller file size + if 'optimizer' in checkpoint: + del checkpoint['optimizer'] + if 'message_hub' in checkpoint: + del checkpoint['message_hub'] + if 'ema_state_dict' in checkpoint: + del checkpoint['ema_state_dict'] + + for key in list(checkpoint['state_dict']): + if key.startswith('data_preprocessor'): + checkpoint['state_dict'].pop(key) + elif 'priors_base_sizes' in key: + checkpoint['state_dict'].pop(key) + elif 'grid_offset' in key: + checkpoint['state_dict'].pop(key) + elif 'prior_inds' in key: + checkpoint['state_dict'].pop(key) + + # if it is necessary to remove some sensitive data in checkpoint['meta'], + # add the code here. + if torch.__version__ >= '1.6': + torch.save(checkpoint, out_file, _use_new_zipfile_serialization=False) + else: + torch.save(checkpoint, out_file) + sha = subprocess.check_output(['sha256sum', out_file]).decode() + final_file = out_file.rstrip('.pth') + f'-{sha[:8]}.pth' + subprocess.Popen(['mv', out_file, final_file]) + return final_file + + +def is_by_epoch(config): + cfg = Config.fromfile('./configs/' + config) + return cfg.train_cfg.type == 'EpochBasedTrainLoop' + + +def get_final_epoch_or_iter(config): + cfg = Config.fromfile('./configs/' + config) + if cfg.train_cfg.type == 'EpochBasedTrainLoop': + return cfg.train_cfg.max_epochs + else: + return cfg.train_cfg.max_iters + + +def get_best_epoch_or_iter(exp_dir): + best_epoch_iter_full_path = list( + sorted(glob.glob(osp.join(exp_dir, 'best_*.pth'))))[-1] + best_epoch_or_iter_model_path = best_epoch_iter_full_path.split('/')[-1] + best_epoch_or_iter = best_epoch_or_iter_model_path. \ + split('_')[-1].split('.')[0] + return best_epoch_or_iter_model_path, int(best_epoch_or_iter) + + +def get_real_epoch_or_iter(config): + cfg = Config.fromfile('./configs/' + config) + if cfg.train_cfg.type == 'EpochBasedTrainLoop': + epoch = cfg.train_cfg.max_epochs + return epoch + else: + return cfg.runner.max_iters + + +def get_final_results(log_json_path, + epoch_or_iter, + results_lut='coco/bbox_mAP', + by_epoch=True): + result_dict = dict() + with open(log_json_path) as f: + r = f.readlines()[-1] + last_metric = r.split(',')[0].split(': ')[-1].strip() + result_dict[results_lut] = last_metric + return result_dict + + +def get_dataset_name(config): + # If there are more dataset, add here. + name_map = dict( + CityscapesDataset='Cityscapes', + CocoDataset='COCO', + PoseCocoDataset='COCO Person', + YOLOv5CocoDataset='COCO', + CocoPanopticDataset='COCO', + YOLOv5DOTADataset='DOTA 1.0', + DeepFashionDataset='Deep Fashion', + LVISV05Dataset='LVIS v0.5', + LVISV1Dataset='LVIS v1', + VOCDataset='Pascal VOC', + YOLOv5VOCDataset='Pascal VOC', + WIDERFaceDataset='WIDER Face', + OpenImagesDataset='OpenImagesDataset', + OpenImagesChallengeDataset='OpenImagesChallengeDataset') + cfg = Config.fromfile('./configs/' + config) + return name_map[cfg.dataset_type] + + +def find_last_dir(model_dir): + dst_times = [] + for time_stamp in os.scandir(model_dir): + if osp.isdir(time_stamp): + dst_time = time.mktime( + time.strptime(time_stamp.name, '%Y%m%d_%H%M%S')) + dst_times.append([dst_time, time_stamp.name]) + return max(dst_times, key=lambda x: x[0])[1] + + +def convert_model_info_to_pwc(model_infos): + pwc_files = {} + for model in model_infos: + cfg_folder_name = osp.split(model['config'])[-2] + pwc_model_info = OrderedDict() + pwc_model_info['Name'] = osp.split(model['config'])[-1].split('.')[0] + pwc_model_info['In Collection'] = 'Please fill in Collection name' + pwc_model_info['Config'] = osp.join('configs', model['config']) + + # get metadata + meta_data = OrderedDict() + if 'epochs' in model: + meta_data['Epochs'] = get_real_epoch_or_iter(model['config']) + else: + meta_data['Iterations'] = get_real_epoch_or_iter(model['config']) + pwc_model_info['Metadata'] = meta_data + + # get dataset name + dataset_name = get_dataset_name(model['config']) + + # get results + results = [] + # if there are more metrics, add here. + if 'bbox_mAP' in model['results']: + metric = round(model['results']['bbox_mAP'] * 100, 1) + results.append( + OrderedDict( + Task='Object Detection', + Dataset=dataset_name, + Metrics={'box AP': metric})) + if 'segm_mAP' in model['results']: + metric = round(model['results']['segm_mAP'] * 100, 1) + results.append( + OrderedDict( + Task='Instance Segmentation', + Dataset=dataset_name, + Metrics={'mask AP': metric})) + if 'PQ' in model['results']: + metric = round(model['results']['PQ'], 1) + results.append( + OrderedDict( + Task='Panoptic Segmentation', + Dataset=dataset_name, + Metrics={'PQ': metric})) + pwc_model_info['Results'] = results + + link_string = 'https://download.openmmlab.com/mmyolo/v0/' + link_string += '{}/{}'.format(model['config'].rstrip('.py'), + osp.split(model['model_path'])[-1]) + pwc_model_info['Weights'] = link_string + if cfg_folder_name in pwc_files: + pwc_files[cfg_folder_name].append(pwc_model_info) + else: + pwc_files[cfg_folder_name] = [pwc_model_info] + return pwc_files + + +def parse_args(): + parser = argparse.ArgumentParser(description='Gather benchmarked models') + parser.add_argument( + 'root', + type=str, + help='root path of benchmarked models to be gathered') + parser.add_argument( + 'out', type=str, help='output path of gathered models to be stored') + parser.add_argument( + '--best', + action='store_true', + help='whether to gather the best model.') + + args = parser.parse_args() + return args + + +# TODO: Refine +def main(): + args = parse_args() + models_root = args.root + models_out = args.out + mkdir_or_exist(models_out) + + # find all models in the root directory to be gathered + raw_configs = list(scandir('./configs', '.py', recursive=True)) + + # filter configs that is not trained in the experiments dir + used_configs = [] + for raw_config in raw_configs: + if osp.exists(osp.join(models_root, raw_config)): + used_configs.append(raw_config) + print(f'Find {len(used_configs)} models to be gathered') + + # find final_ckpt and log file for trained each config + # and parse the best performance + model_infos = [] + for used_config in used_configs: + exp_dir = osp.join(models_root, used_config) + by_epoch = is_by_epoch(used_config) + # check whether the exps is finished + if args.best is True: + final_model, final_epoch_or_iter = get_best_epoch_or_iter(exp_dir) + else: + final_epoch_or_iter = get_final_epoch_or_iter(used_config) + final_model = '{}_{}.pth'.format('epoch' if by_epoch else 'iter', + final_epoch_or_iter) + + model_path = osp.join(exp_dir, final_model) + # skip if the model is still training + if not osp.exists(model_path): + continue + + # get the latest logs + latest_exp_name = find_last_dir(exp_dir) + latest_exp_json = osp.join(exp_dir, latest_exp_name, 'vis_data', + latest_exp_name + '.json') + + model_performance = get_final_results( + latest_exp_json, final_epoch_or_iter, by_epoch=by_epoch) + + if model_performance is None: + continue + + model_info = dict( + config=used_config, + results=model_performance, + final_model=final_model, + latest_exp_json=latest_exp_json, + latest_exp_name=latest_exp_name) + model_info['epochs' if by_epoch else 'iterations'] = \ + final_epoch_or_iter + model_infos.append(model_info) + + # publish model for each checkpoint + publish_model_infos = [] + for model in model_infos: + model_publish_dir = osp.join(models_out, model['config'].rstrip('.py')) + mkdir_or_exist(model_publish_dir) + + model_name = osp.split(model['config'])[-1].split('.')[0] + + model_name += '_' + model['latest_exp_name'] + publish_model_path = osp.join(model_publish_dir, model_name) + trained_model_path = osp.join(models_root, model['config'], + model['final_model']) + + # convert model + final_model_path = process_checkpoint(trained_model_path, + publish_model_path) + + # copy log + shutil.copy(model['latest_exp_json'], + osp.join(model_publish_dir, f'{model_name}.log.json')) + + # copy config to guarantee reproducibility + config_path = model['config'] + config_path = osp.join( + 'configs', + config_path) if 'configs' not in config_path else config_path + target_config_path = osp.split(config_path)[-1] + shutil.copy(config_path, osp.join(model_publish_dir, + target_config_path)) + + model['model_path'] = final_model_path + publish_model_infos.append(model) + + models = dict(models=publish_model_infos) + print(f'Totally gathered {len(publish_model_infos)} models') + dump(models, osp.join(models_out, 'model_info.json')) + + pwc_files = convert_model_info_to_pwc(publish_model_infos) + for name in pwc_files: + with open(osp.join(models_out, name + '_metafile.yml'), 'w') as f: + ordered_yaml_dump(pwc_files[name], f, encoding='utf-8') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.dev_scripts/print_registers.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.dev_scripts/print_registers.py new file mode 100644 index 0000000000000000000000000000000000000000..52646da205969db62d3d59dc2736be00954510e2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.dev_scripts/print_registers.py @@ -0,0 +1,448 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import importlib +import os +import os.path as osp +import pkgutil +import sys +import tempfile +from multiprocessing import Pool +from pathlib import Path + +import numpy as np +import pandas as pd + +# host_addr = 'https://gitee.com/open-mmlab' +host_addr = 'https://github.com/open-mmlab' +tools_list = ['tools', '.dev_scripts'] +proxy_names = { + 'mmdet': 'mmdetection', + 'mmseg': 'mmsegmentation', + 'mmcls': 'mmclassification' +} +merge_module_keys = {'mmcv': ['mmengine']} +# exclude_prefix = {'mmcv': ['{_k}') + table_data.append((registry_name, registry_strings)) + + # sort the data list + table_data = sorted(table_data, key=lambda x: len(x[1])) + # split multi parts + table_data_multi_parts = [] + for (registry_name, registry_strings) in table_data: + multi_parts = False + if len(registry_strings) > max_size_per_cell: + multi_parts = True + for cell_idx, registry_cell in enumerate( + divide_list_into_groups(registry_strings, max_size_per_cell)): + registry_str = ''.join(registry_cell.tolist()) + registry_str = f'
    {registry_str}
' + table_data_multi_parts.append([ + registry_name if not multi_parts else + f'{registry_name} (part {cell_idx + 1})', registry_str + ]) + + for table_data in divide_list_into_groups(table_data_multi_parts, + max_col_per_row): + table_data = list(zip(*table_data.tolist())) + html += dataframe_to_html( + pd.DataFrame([table_data[1]], columns=table_data[0])) + if html: + html = f'
{title}
\n{html}' + html = f'
{html}
\n' + return html + + +def tools_to_html(tools_dict, repo_name=''): + + def _recurse(_dict, _connector, _result): + assert isinstance(_dict, dict), \ + f'unknown recurse type: {_dict} ({type(_dict)})' + for _k, _v in _dict.items(): + if _v is None: + if _connector not in _result: + _result[_connector] = [] + _result[_connector].append(_k) + else: + _recurse(_v, osp.join(_connector, _k), _result) + + table_data = {} + title = f'{capitalize(repo_name)} Tools' + _recurse(tools_dict, '', table_data) + return registries_to_html(table_data, title) + + +def dataframe_to_html(dataframe): + styler = dataframe.style + styler = styler.hide(axis='index') + styler = styler.format(na_rep='-') + styler = styler.set_properties(**{ + 'text-align': 'left', + 'align': 'center', + 'vertical-align': 'top' + }) + styler = styler.set_table_styles([{ + 'selector': + 'thead th', + 'props': + 'align:center;text-align:center;vertical-align:bottom' + }]) + html = styler.to_html() + html = f'
\n{html}
' + return html + + +def generate_markdown_by_repository(repo_name, + module_name, + branch, + pulldir, + throw_error=False): + # add the pull dir to the system path so that it can be found + if pulldir not in sys.path: + sys.path.insert(0, pulldir) + module_list, error_dict = load_modules_from_dir( + module_name, pulldir, throw_error=throw_error) + registries_tree = get_registries_from_modules(module_list) + if error_dict: + error_dict_name = 'error_modules' + assert (error_dict_name not in registries_tree), \ + f'duplicate module name was found: {error_dict_name}' + registries_tree.update({error_dict_name: error_dict}) + # get the tools files + for tools_name in tools_list: + assert (tools_name not in registries_tree), \ + f'duplicate tools name was found: {tools_name}' + tools_tree = osp.join(pulldir, tools_name) + tools_tree = get_scripts_from_dir(tools_tree) + registries_tree.update({tools_name: tools_tree}) + # print_tree(registries_tree) + # get registries markdown string + module_registries = registries_tree.get(module_name, {}) + for merge_key in merge_module_keys.get(module_name, []): + merge_dict = registries_tree.get(merge_key, {}) + merge_registries(module_registries, merge_dict) + for exclude_key in exclude_prefix.get(module_name, []): + exclude_registries(module_registries, exclude_key) + markdown_str = registries_to_html( + module_registries, title=f'{capitalize(repo_name)} Module Components') + # get tools markdown string + tools_registries = {} + for tools_name in tools_list: + tools_registries.update( + {tools_name: registries_tree.get(tools_name, {})}) + markdown_str += tools_to_html(tools_registries, repo_name=repo_name) + version_str = get_version_from_module_name(module_name, branch) + title_str = f'\n\n## {capitalize(repo_name)}{version_str}\n' + # remove the pull dir from system path + if pulldir in sys.path: + sys.path.remove(pulldir) + return f'{title_str}{markdown_str}' + + +def parse_args(): + parser = argparse.ArgumentParser( + description='print registries in openmmlab repositories') + parser.add_argument( + '-r', + '--repositories', + nargs='+', + default=['mmdet', 'mmcls', 'mmseg', 'mmengine', 'mmcv'], + type=str, + help='git repositories name in OpenMMLab') + parser.add_argument( + '-b', + '--branches', + nargs='+', + default=['3.x', '1.x', '1.x', 'main', '2.x'], + type=str, + help='the branch names of git repositories, the length of branches ' + 'must be same as the length of repositories') + parser.add_argument( + '-o', '--out', type=str, default='.', help='output path of the file') + parser.add_argument( + '--throw-error', + action='store_true', + default=False, + help='whether to throw error when trying to import modules') + args = parser.parse_args() + return args + + +# TODO: Refine +def main(): + args = parse_args() + repositories = args.repositories + branches = args.branches + assert isinstance(repositories, list), \ + 'Type of repositories must be list' + if branches is None: + branches = [None] * len(repositories) + assert isinstance(branches, list) and \ + len(branches) == len(repositories), \ + 'The length of branches must be same as ' \ + 'that of repositories' + assert isinstance(args.out, str), \ + 'The type of output path must be string' + # save path of file + mkdir_or_exist(args.out) + save_path = osp.join(args.out, 'registries_info.md') + with tempfile.TemporaryDirectory() as tmpdir: + # multi process init + pool = Pool(processes=len(repositories)) + multi_proc_input_list = [] + multi_proc_output_list = [] + # get the git repositories + for branch, repository in zip(branches, repositories): + repo_name, module_name = parse_repo_name(repository) + pulldir = osp.join(tmpdir, f'tmp_{repo_name}') + git_pull_branch( + repo_name=repo_name, branch_name=branch, pulldir=pulldir) + multi_proc_input_list.append( + (repo_name, module_name, branch, pulldir, args.throw_error)) + print('starting the multi process to get the registries') + for multi_proc_input in multi_proc_input_list: + multi_proc_output_list.append( + pool.apply_async(generate_markdown_by_repository, + multi_proc_input)) + pool.close() + pool.join() + with open(save_path, 'w', encoding='utf-8') as fw: + fw.write(f'{markdown_title}\n') + for multi_proc_output in multi_proc_output_list: + markdown_str = multi_proc_output.get() + fw.write(f'{markdown_str}\n') + print(f'saved registries to the path: {save_path}') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/CODE_OF_CONDUCT.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000000000000000000000000000000000..92afad1c5ab5d5781115dee45c131d3751d3cd31 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +- Using welcoming and inclusive language +- Being respectful of differing viewpoints and experiences +- Gracefully accepting constructive criticism +- Focusing on what is best for the community +- Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +- The use of sexualized language or imagery and unwelcome sexual attention or + advances +- Trolling, insulting/derogatory comments, and personal or political attacks +- Public or private harassment +- Publishing others' private information, such as a physical or electronic + address, without explicit permission +- Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at chenkaidev@gmail.com. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq + +[homepage]: https://www.contributor-covenant.org diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/CONTRIBUTING.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..4ac764f10587497cb6da5ba453c08056d5bc9df7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/CONTRIBUTING.md @@ -0,0 +1 @@ +We appreciate all contributions to improve MMYOLO. Please refer to [CONTRIBUTING.md](https://github.com/open-mmlab/mmcv/blob/master/CONTRIBUTING.md) in MMCV for more details about the contributing guideline. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/1-bug-report.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/1-bug-report.yml new file mode 100644 index 0000000000000000000000000000000000000000..0cec5853ebbde572c2c6322f9d7123cac5a97df7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/1-bug-report.yml @@ -0,0 +1,67 @@ +name: "🐞 Bug report" +description: "Create a report to help us reproduce and fix the bug" + + +body: + - type: markdown + attributes: + value: | + Thank you for reporting this issue to help us improve! + If you have already identified the reason, we strongly appreciate you creating a new PR to fix it [here](https://github.com/open-mmlab/mmyolo/pulls)! + If this issue is about installing MMCV, please file an issue at [MMCV](https://github.com/open-mmlab/mmcv/issues/new/choose). + If you need our help, please fill in as much of the following form as you're able. + + - type: checkboxes + attributes: + label: Prerequisite + description: Please check the following items before creating a new issue. + options: + - label: I have searched [the existing and past issues](https://github.com/open-mmlab/mmyolo/issues) but cannot get the expected help. + required: true + - label: I have read the [FAQ documentation](https://mmyolo.readthedocs.io/en/latest/faq.html) but cannot get the expected help. + required: true + - label: The bug has not been fixed in the [latest version](https://github.com/open-mmlab/mmyolo). + required: true + + - type: textarea + attributes: + label: 🐞 Describe the bug + description: | + Please provide a clear and concise description of what the bug is. + Preferably a simple and minimal code snippet that we can reproduce the error by running the code. + placeholder: | + A clear and concise description of what the bug is. + + ```python + # Sample code to reproduce the problem + ``` + + ```shell + The command or script you run. + ``` + + ``` + The error message or logs you got, with the full traceback. + ``` + validations: + required: true + + - type: textarea + attributes: + label: Environment + description: | + Please run `python mmyolo/utils/collect_env.py` to collect necessary environment information and paste it here. + You may add addition that may be helpful for locating the problem, such as + - How you installed PyTorch \[e.g., pip, conda, source\] + - Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.) + validations: + required: true + + - type: textarea + attributes: + label: Additional information + description: Tell us anything else you think we should know. + placeholder: | + 1. Did you make any modifications on the code or config? Did you understand what you have modified? + 2. What dataset did you use? + 3. What do you think might be the reason? diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/2-feature-request.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/2-feature-request.yml new file mode 100644 index 0000000000000000000000000000000000000000..8b24846777e89685bcb99c5d79663839536b6607 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/2-feature-request.yml @@ -0,0 +1,32 @@ +name: 🚀 Feature request +description: Suggest an idea for this project +labels: [feature request] + +body: + - type: markdown + attributes: + value: | + Thank you for suggesting an idea to make MMYOLO better. + We strongly appreciate you creating a PR to implete this feature [here](https://github.com/open-mmlab/mmyolo/pulls)! + + If you need our help, please fill in as much of the following form as you're able. + + - type: textarea + attributes: + label: What is the problem this feature will solve? + placeholder: | + E.g., It is inconvenient when \[....\]. + validations: + required: true + + - type: textarea + attributes: + label: What is the feature you are proposing to solve the problem? + validations: + required: true + + - type: textarea + attributes: + label: What alternatives have you considered? + description: | + Add any other context or screenshots about the feature request here. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/3-new-model.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/3-new-model.yml new file mode 100644 index 0000000000000000000000000000000000000000..2aacff4abc353c1e999c8e5952c86ffcac38b063 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/3-new-model.yml @@ -0,0 +1,30 @@ +name: "\U0001F31F New model/dataset addition" +description: Submit a proposal/request to implement a new model / dataset +labels: [ "New model/dataset" ] + +body: + - type: textarea + id: description-request + validations: + required: true + attributes: + label: Model/Dataset description + description: | + Put any and all important information relative to the model/dataset + + - type: checkboxes + attributes: + label: Open source status + description: | + Please provide the open-source status, which would be very helpful + options: + - label: "The model implementation is available" + - label: "The model weights are available." + + - type: textarea + id: additional-info + attributes: + label: Provide useful links for the implementation + description: | + Please provide information regarding the implementation, the weights, and the authors. + Please mention the authors by @gh-username if you're aware of their usernames. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/4-documentation.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/4-documentation.yml new file mode 100644 index 0000000000000000000000000000000000000000..dbf1ef8107a33c41067743097ba78e047be43cdb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/4-documentation.yml @@ -0,0 +1,22 @@ +name: 📚 Documentation +description: Report an issue related to https://mmyolo.readthedocs.io/en/latest/. + +body: +- type: textarea + attributes: + label: 📚 The doc issue + description: > + A clear and concise description of what content in https://mmyolo.readthedocs.io/en/latest/ is an issue. + validations: + required: true + +- type: textarea + attributes: + label: Suggest a potential alternative/fix + description: > + Tell us how we could improve the documentation in this regard. + +- type: markdown + attributes: + value: > + Thanks for contributing 🎉! diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/5-reimplementation.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/5-reimplementation.yml new file mode 100644 index 0000000000000000000000000000000000000000..1240aa896a50151ad47cc1bf0813d0b40d7e7169 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/5-reimplementation.yml @@ -0,0 +1,87 @@ +name: "💥 Reimplementation Questions" +description: "Ask about questions during model reimplementation" + + +body: + - type: markdown + attributes: + value: | + If you have already identified the reason, we strongly appreciate you creating a new PR to fix it [here](https://github.com/open-mmlab/mmyolo/pulls)! + + - type: checkboxes + attributes: + label: Prerequisite + description: Please check the following items before creating a new issue. + options: + - label: I have searched [the existing and past issues](https://github.com/open-mmlab/mmyolo/issues) but cannot get the expected help. + required: true + - label: I have read the [FAQ documentation](https://mmyolo.readthedocs.io/en/latest/faq.html) but cannot get the expected help. + required: true + - label: The bug has not been fixed in the [latest version](https://github.com/open-mmlab/mmyolo). + required: true + validations: + required: true + + - type: textarea + attributes: + label: 💬 Describe the reimplementation questions + description: | + A clear and concise description of what the problem you meet and what have you done. + There are several common situations in the reimplementation issues as below + + 1. Reimplement a model in the model zoo using the provided configs + 2. Reimplement a model in the model zoo on other dataset (e.g., custom datasets) + 3. Reimplement a custom model but all the components are implemented in MMDetection + 4. Reimplement a custom model with new modules implemented by yourself + + There are several things to do for different cases as below. + + - For case 1 & 3, please follow the steps in the following sections thus we could help to quick identify the issue. + - For case 2 & 4, please understand that we are not able to do much help here because we usually do not know the full code and the users should be responsible to the code they write. + - One suggestion for case 2 & 4 is that the users should first check whether the bug lies in the self-implemented code or the original code. For example, users can first make sure that the same model runs well on supported datasets. If you still need help, please describe what you have done and what you obtain in the issue, and follow the steps in the following sections and try as clear as possible so that we can better help you. + placeholder: | + A clear and concise description of what the bug is. + What config dir you run? + + ```none + A placeholder for the config. + ``` + + ```shell + The command or script you run. + ``` + + ``` + The error message or logs you got, with the full traceback. + ``` + validations: + required: true + + - type: textarea + attributes: + label: Environment + description: | + Please run `python mmyolo/utils/collect_env.py` to collect necessary environment information and paste it here. + You may add addition that may be helpful for locating the problem, such as + - How you installed PyTorch \[e.g., pip, conda, source\] + - Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.) + validations: + required: true + + - type: textarea + attributes: + label: Expected results + description: If applicable, paste the related results here, e.g., what you expect and what you get. + placeholder: | + ```none + A placeholder for results comparison + ``` + + - type: textarea + attributes: + label: Additional information + description: Tell us anything else you think we should know. + placeholder: | + 1. Did you make any modifications on the code or config? Did you understand what you have modified? + 2. What dataset did you use? + 3. What do you think might be the reason? diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/config.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000000000000000000000000000000000000..585c786b50b3692e996a1d150470852e876a24dc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,9 @@ +blank_issues_enabled: true + +contact_links: + - name: 💬 Forum + url: https://github.com/open-mmlab/mmyolo/discussions + about: Ask general usage questions and discuss with other MMYOLO community members + - name: 🌐 Explore OpenMMLab + url: https://openmmlab.com/ + about: Get know more about OpenMMLab diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/pull_request_template.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/pull_request_template.md new file mode 100644 index 0000000000000000000000000000000000000000..2997d883eec5e36302b7a4505f2d218f5cdf7c91 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/pull_request_template.md @@ -0,0 +1,25 @@ +Thanks for your contribution and we appreciate it a lot. The following instructions would make your pull request more healthy and more easily get feedback. If you do not understand some items, don't worry, just make the pull request and seek help from maintainers. + +## Motivation + +Please describe the motivation for this PR and the goal you want to achieve through this PR. + +## Modification + +Please briefly describe what modification is made in this PR. + +## BC-breaking (Optional) + +Does the modification introduce changes that break the backward compatibility of the downstream repos? +If so, please describe how it breaks the compatibility and how the downstream projects should modify their code to keep compatibility with this PR. + +## Use cases (Optional) + +If this PR introduces a new feature, it is better to list some use cases here and update the documentation. + +## Checklist + +1. Pre-commit or other linting tools are used to fix potential lint issues. +2. The modification is covered by complete unit tests. If not, please add more unit tests to ensure the correctness. +3. If the modification has a potential influence on downstream projects, this PR should be tested with downstream projects, like MMDetection or MMClassification. +4. The documentation has been modified accordingly, like docstring or example tutorials. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/workflows/deploy.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/workflows/deploy.yml new file mode 100644 index 0000000000000000000000000000000000000000..08f542bbaaae1a1f0f33712544e1ff08c7aa2e85 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.github/workflows/deploy.yml @@ -0,0 +1,28 @@ +name: deploy + +on: push + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-n-publish: + runs-on: ubuntu-latest + if: startsWith(github.event.ref, 'refs/tags') + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.7 + uses: actions/setup-python@v2 + with: + python-version: 3.7 + - name: Install torch + run: pip install torch + - name: Install wheel + run: pip install wheel + - name: Build MMYOLO + run: python setup.py sdist bdist_wheel + - name: Publish distribution to PyPI + run: | + pip install twine + twine upload dist/* -u __token__ -p ${{ secrets.pypi_password }} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.gitignore b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..195f1940ad4e0cd1c73a8192c474b816dea93978 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.gitignore @@ -0,0 +1,126 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/en/_build/ +docs/zh_cn/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +data/ +data +.vscode +.idea +.DS_Store + +# custom +*.pkl +*.pkl.json +*.log.json +docs/modelzoo_statistics.md +mmyolo/.mim +output/ +work_dirs +yolov5-6.1/ + +# Pytorch +*.pth +*.pt +*.py~ +*.sh~ diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.pre-commit-config-zh-cn.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.pre-commit-config-zh-cn.yaml new file mode 100644 index 0000000000000000000000000000000000000000..52bb607e86cedc4f0ac9d188bb7ec717d88b35fb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.pre-commit-config-zh-cn.yaml @@ -0,0 +1,60 @@ +exclude: ^tests/data/ +repos: + - repo: https://gitee.com/openmmlab/mirrors-flake8 + rev: 5.0.4 + hooks: + - id: flake8 + - repo: https://gitee.com/openmmlab/mirrors-isort + rev: 5.11.5 + hooks: + - id: isort + - repo: https://gitee.com/openmmlab/mirrors-yapf + rev: v0.32.0 + hooks: + - id: yapf + - repo: https://gitee.com/openmmlab/mirrors-pre-commit-hooks + rev: v4.3.0 + hooks: + - id: trailing-whitespace + - id: check-yaml + - id: end-of-file-fixer + - id: requirements-txt-fixer + - id: double-quote-string-fixer + - id: check-merge-conflict + - id: fix-encoding-pragma + args: ["--remove"] + - id: mixed-line-ending + args: ["--fix=lf"] + - repo: https://gitee.com/openmmlab/mirrors-mdformat + rev: 0.7.9 + hooks: + - id: mdformat + args: ["--number"] + additional_dependencies: + - mdformat-openmmlab + - mdformat_frontmatter + - linkify-it-py + - repo: https://gitee.com/openmmlab/mirrors-codespell + rev: v2.2.1 + hooks: + - id: codespell + - repo: https://gitee.com/openmmlab/mirrors-docformatter + rev: v1.3.1 + hooks: + - id: docformatter + args: ["--in-place", "--wrap-descriptions", "79"] + - repo: https://gitee.com/openmmlab/mirrors-pyupgrade + rev: v3.0.0 + hooks: + - id: pyupgrade + args: ["--py36-plus"] + - repo: https://github.com/open-mmlab/pre-commit-hooks + rev: v0.2.0 + hooks: + - id: check-copyright + args: ["mmyolo", "tests"] +# - repo: https://gitee.com/openmmlab/mirrors-mypy +# rev: v0.812 +# hooks: +# - id: mypy +# exclude: "docs" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.pre-commit-config.yaml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.pre-commit-config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ffae20d2d3941607fd541e03e22c0e351f296d88 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.pre-commit-config.yaml @@ -0,0 +1,60 @@ +exclude: ^tests/data/ +repos: + - repo: https://github.com/PyCQA/flake8 + rev: 5.0.4 + hooks: + - id: flake8 + - repo: https://github.com/PyCQA/isort + rev: 5.11.5 + hooks: + - id: isort + - repo: https://github.com/pre-commit/mirrors-yapf + rev: v0.32.0 + hooks: + - id: yapf + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.3.0 + hooks: + - id: trailing-whitespace + - id: check-yaml + - id: end-of-file-fixer + - id: requirements-txt-fixer + - id: double-quote-string-fixer + - id: check-merge-conflict + - id: fix-encoding-pragma + args: ["--remove"] + - id: mixed-line-ending + args: ["--fix=lf"] + - repo: https://github.com/executablebooks/mdformat + rev: 0.7.9 + hooks: + - id: mdformat + args: ["--number"] + additional_dependencies: + - mdformat-openmmlab + - mdformat_frontmatter + - linkify-it-py + - repo: https://github.com/codespell-project/codespell + rev: v2.2.1 + hooks: + - id: codespell + - repo: https://github.com/myint/docformatter + rev: v1.3.1 + hooks: + - id: docformatter + args: ["--in-place", "--wrap-descriptions", "79"] + - repo: https://github.com/asottile/pyupgrade + rev: v3.0.0 + hooks: + - id: pyupgrade + args: ["--py36-plus"] + - repo: https://github.com/open-mmlab/pre-commit-hooks + rev: v0.2.0 + hooks: + - id: check-copyright + args: ["mmyolo", "tests"] +# - repo: https://github.com/pre-commit/mirrors-mypy +# rev: v0.812 +# hooks: +# - id: mypy +# exclude: "docs" diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.readthedocs.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.readthedocs.yml new file mode 100644 index 0000000000000000000000000000000000000000..c9ab01ce18caeebce129472bd63b0465405d6a50 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/.readthedocs.yml @@ -0,0 +1,8 @@ +version: 2 + +formats: all + +python: + version: 3.7 + install: + - requirements: requirements/docs.txt diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/LICENSE b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f288702d2fa16d3cdf0035b15a9fcbc552cd88e7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/MANIFEST.in b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..5bf1d9ebabcc5ca1f28207b62eab10141474db51 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/MANIFEST.in @@ -0,0 +1,6 @@ +include requirements/*.txt +include mmyolo/VERSION +include mmyolo/.mim/model-index.yml +include mmyolo/.mim/demo/*/* +recursive-include mmyolo/.mim/configs *.py *.yml +recursive-include mmyolo/.mim/tools *.sh *.py diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b799a759c367938cbeea728b0763a36cda5b2544 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/README.md @@ -0,0 +1,428 @@ +
+ +
 
+
+ OpenMMLab website + + + HOT + + +      + OpenMMLab platform + + + TRY IT OUT + + +
+
 
+ +[![PyPI](https://img.shields.io/pypi/v/mmyolo)](https://pypi.org/project/mmyolo) +[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmyolo.readthedocs.io/en/latest/) +[![deploy](https://github.com/open-mmlab/mmyolo/workflows/deploy/badge.svg)](https://github.com/open-mmlab/mmyolo/actions) +[![codecov](https://codecov.io/gh/open-mmlab/mmyolo/branch/main/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmyolo) +[![license](https://img.shields.io/github/license/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/blob/main/LICENSE) +[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues) +[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues) + +[📘Documentation](https://mmyolo.readthedocs.io/en/latest/) | +[🛠️Installation](https://mmyolo.readthedocs.io/en/latest/get_started/installation.html) | +[👀Model Zoo](https://mmyolo.readthedocs.io/en/latest/model_zoo.html) | +[🆕Update News](https://mmyolo.readthedocs.io/en/latest/notes/changelog.html) | +[🤔Reporting Issues](https://github.com/open-mmlab/mmyolo/issues/new/choose) + +
+ +
+ +English | [简体中文](README_zh-CN.md) + +
+ +
+ + + + + + + + + + + + + + + + + +
+ +## 📄 Table of Contents + +- [🥳 🚀 What's New](#--whats-new-) + - [✨ Highlight](#-highlight-) +- [📖 Introduction](#-introduction-) +- [🛠️ Installation](#%EF%B8%8F-installation-) +- [👨‍🏫 Tutorial](#-tutorial-) +- [📊 Overview of Benchmark and Model Zoo](#-overview-of-benchmark-and-model-zoo-) +- [❓ FAQ](#-faq-) +- [🙌 Contributing](#-contributing-) +- [🤝 Acknowledgement](#-acknowledgement-) +- [🖊️ Citation](#️-citation-) +- [🎫 License](#-license-) +- [🏗️ Projects in OpenMMLab](#%EF%B8%8F-projects-in-openmmlab-) + +## 🥳 🚀 What's New [🔝](#-table-of-contents) + +💎 **v0.6.0** was released on 15/8/2023: + +- Support YOLOv5 instance segmentation +- Support YOLOX-Pose based on MMPose +- Add 15 minutes instance segmentation tutorial. +- YOLOv5 supports using mask annotation to optimize bbox +- Add Multi-scale training and testing docs + +For release history and update details, please refer to [changelog](https://mmyolo.readthedocs.io/en/latest/notes/changelog.html). + +### ✨ Highlight [🔝](#-table-of-contents) + +We are excited to announce our latest work on real-time object recognition tasks, **RTMDet**, a family of fully convolutional single-stage detectors. RTMDet not only achieves the best parameter-accuracy trade-off on object detection from tiny to extra-large model sizes but also obtains new state-of-the-art performance on instance segmentation and rotated object detection tasks. Details can be found in the [technical report](https://arxiv.org/abs/2212.07784). Pre-trained models are [here](configs/rtmdet). + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + +| Task | Dataset | AP | FPS(TRT FP16 BS1 3090) | +| ------------------------ | ------- | ------------------------------------ | ---------------------- | +| Object Detection | COCO | 52.8 | 322 | +| Instance Segmentation | COCO | 44.6 | 188 | +| Rotated Object Detection | DOTA | 78.9(single-scale)/81.3(multi-scale) | 121 | + +
+ +
+ +MMYOLO currently implements the object detection and rotated object detection algorithm, but it has a significant training acceleration compared to the MMDeteciton version. The training speed is 2.6 times faster than the previous version. + +## 📖 Introduction [🔝](#-table-of-contents) + +MMYOLO is an open source toolbox for YOLO series algorithms based on PyTorch and [MMDetection](https://github.com/open-mmlab/mmdetection). It is a part of the [OpenMMLab](https://openmmlab.com/) project. + +The master branch works with **PyTorch 1.6+**. + + +
+Major features + +- 🕹️ **Unified and convenient benchmark** + + MMYOLO unifies the implementation of modules in various YOLO algorithms and provides a unified benchmark. Users can compare and analyze in a fair and convenient way. + +- 📚 **Rich and detailed documentation** + + MMYOLO provides rich documentation for getting started, model deployment, advanced usages, and algorithm analysis, making it easy for users at different levels to get started and make extensions quickly. + +- 🧩 **Modular Design** + + MMYOLO decomposes the framework into different components where users can easily customize a model by combining different modules with various training and testing strategies. + +BaseModule-P5 + The figure above is contributed by RangeKing@GitHub, thank you very much! + +And the figure of P6 model is in [model_design.md](docs/en/recommended_topics/model_design.md). + +
+ +## 🛠️ Installation [🔝](#-table-of-contents) + +MMYOLO relies on PyTorch, MMCV, MMEngine, and MMDetection. Below are quick steps for installation. Please refer to the [Install Guide](docs/en/get_started/installation.md) for more detailed instructions. + +```shell +conda create -n mmyolo python=3.8 pytorch==1.10.1 torchvision==0.11.2 cudatoolkit=11.3 -c pytorch -y +conda activate mmyolo +pip install openmim +mim install "mmengine>=0.6.0" +mim install "mmcv>=2.0.0rc4,<2.1.0" +mim install "mmdet>=3.0.0,<4.0.0" +git clone https://github.com/open-mmlab/mmyolo.git +cd mmyolo +# Install albumentations +pip install -r requirements/albu.txt +# Install MMYOLO +mim install -v -e . +``` + +## 👨‍🏫 Tutorial [🔝](#-table-of-contents) + +MMYOLO is based on MMDetection and adopts the same code structure and design approach. To get better use of this, please read [MMDetection Overview](https://mmdetection.readthedocs.io/en/latest/get_started.html) for the first understanding of MMDetection. + +The usage of MMYOLO is almost identical to MMDetection and all tutorials are straightforward to use, you can also learn about [MMDetection User Guide and Advanced Guide](https://mmdetection.readthedocs.io/en/3.x/). + +For different parts from MMDetection, we have also prepared user guides and advanced guides, please read our [documentation](https://mmyolo.readthedocs.io/zenh_CN/latest/). + +
+Get Started + +- [Overview](docs/en/get_started/overview.md) +- [Dependencies](docs/en/get_started/dependencies.md) +- [Installation](docs/en/get_started/installation.md) +- [15 minutes object detection](docs/en/get_started/15_minutes_object_detection.md) +- [15 minutes rotated object detection](docs/en/get_started/15_minutes_rotated_object_detection.md) +- [15 minutes instance segmentation](docs/en/get_started/15_minutes_instance_segmentation.md) +- [Resources summary](docs/en/get_started/article.md) + +
+ +
+Recommended Topics + +- [How to contribute code to MMYOLO](docs/en/recommended_topics/contributing.md) +- [Training testing tricks](docs/en/recommended_topics/training_testing_tricks.md) +- [MMYOLO model design](docs/en/recommended_topics/model_design.md) +- [Algorithm principles and implementation](docs/en/recommended_topics/algorithm_descriptions/) +- [Replace the backbone network](docs/en/recommended_topics/replace_backbone.md) +- [MMYOLO model complexity analysis](docs/en/recommended_topics/complexity_analysis.md) +- [Annotation-to-deployment workflow for custom dataset](docs/en/recommended_topics/labeling_to_deployment_tutorials.md) +- [Visualization](docs/en/recommended_topics/visualization.md) +- [Model deployment](docs/en/recommended_topics/deploy/) +- [Troubleshooting steps](docs/en/recommended_topics/troubleshooting_steps.md) +- [MMYOLO application examples](docs/en/recommended_topics/application_examples/) +- [MM series repo essential basics](docs/en/recommended_topics/mm_basics.md) +- [Dataset preparation and description](docs/en/recommended_topics/dataset_preparation.md) + +
+ +
+Common Usage + +- [Resume training](docs/en/common_usage/resume_training.md) +- [Enabling and disabling SyncBatchNorm](docs/en/common_usage/syncbn.md) +- [Enabling AMP](docs/en/common_usage/amp_training.md) +- [Multi-scale training and testing](docs/en/common_usage/ms_training_testing.md) +- [TTA Related Notes](docs/en/common_usage/tta.md) +- [Add plugins to the backbone network](docs/en/common_usage/plugins.md) +- [Freeze layers](docs/en/common_usage/freeze_layers.md) +- [Output model predictions](docs/en/common_usage/output_predictions.md) +- [Set random seed](docs/en/common_usage/set_random_seed.md) +- [Module combination](docs/en/common_usage/module_combination.md) +- [Cross-library calls using mim](docs/en/common_usage/mim_usage.md) +- [Apply multiple Necks](docs/en/common_usage/multi_necks.md) +- [Specify specific device training or inference](docs/en/common_usage/specify_device.md) +- [Single and multi-channel application examples](docs/en/common_usage/single_multi_channel_applications.md) + +
+ +
+Useful Tools + +- [Browse coco json](docs/en/useful_tools/browse_coco_json.md) +- [Browse dataset](docs/en/useful_tools/browse_dataset.md) +- [Print config](docs/en/useful_tools/print_config.md) +- [Dataset analysis](docs/en/useful_tools/dataset_analysis.md) +- [Optimize anchors](docs/en/useful_tools/optimize_anchors.md) +- [Extract subcoco](docs/en/useful_tools/extract_subcoco.md) +- [Visualization scheduler](docs/en/useful_tools/vis_scheduler.md) +- [Dataset converters](docs/en/useful_tools/dataset_converters.md) +- [Download dataset](docs/en/useful_tools/download_dataset.md) +- [Log analysis](docs/en/useful_tools/log_analysis.md) +- [Model converters](docs/en/useful_tools/model_converters.md) + +
+ +
+Basic Tutorials + +- [Learn about configs with YOLOv5](docs/en/tutorials/config.md) +- [Data flow](docs/en/tutorials/data_flow.md) +- [Rotated detection](docs/en/tutorials/rotated_detection.md) +- [Custom Installation](docs/en/tutorials/custom_installation.md) +- [Common Warning Notes](docs/zh_cn/tutorials/warning_notes.md) +- [FAQ](docs/en/tutorials/faq.md) + +
+ +
+Advanced Tutorials + +- [MMYOLO cross-library application](docs/en/advanced_guides/cross-library_application.md) + +
+ +
+Descriptions + +- [Changelog](docs/en/notes/changelog.md) +- [Compatibility](docs/en/notes/compatibility.md) +- [Conventions](docs/en/notes/conventions.md) +- [Code Style](docs/en/notes/code_style.md) + +
+ +## 📊 Overview of Benchmark and Model Zoo [🔝](#-table-of-contents) + +
+ +
+ +Results and models are available in the [model zoo](docs/en/model_zoo.md). + +
+Supported Tasks + +- [x] Object detection +- [x] Rotated object detection + +
+ +
+Supported Algorithms + +- [x] [YOLOv5](configs/yolov5) +- [ ] [YOLOv5u](configs/yolov5/yolov5u) (Inference only) +- [x] [YOLOX](configs/yolox) +- [x] [RTMDet](configs/rtmdet) +- [x] [RTMDet-Rotated](configs/rtmdet) +- [x] [YOLOv6](configs/yolov6) +- [x] [YOLOv7](configs/yolov7) +- [x] [PPYOLOE](configs/ppyoloe) +- [x] [YOLOv8](configs/yolov8) + +
+ +
+Supported Datasets + +- [x] COCO Dataset +- [x] VOC Dataset +- [x] CrowdHuman Dataset +- [x] DOTA 1.0 Dataset + +
+ +
+
+ Module Components +
+ + + + + + + + + + + + + + + + + +
+ Backbones + + Necks + + Loss + + Common +
+
    +
  • YOLOv5CSPDarknet
    • +
  • YOLOv8CSPDarknet
    • +
  • YOLOXCSPDarknet
    • +
  • EfficientRep
    • +
  • CSPNeXt
    • +
  • YOLOv7Backbone
    • +
  • PPYOLOECSPResNet
    • +
  • mmdet backbone
    • +
  • mmcls backbone
    • +
  • timm
    • +
+ 		+
    +
  • YOLOv5PAFPN
    • +
  • YOLOv8PAFPN
    • +
  • YOLOv6RepPAFPN
    • +
  • YOLOXPAFPN
    • +
  • CSPNeXtPAFPN
    • +
  • YOLOv7PAFPN
    • +
  • PPYOLOECSPPAFPN
    • +
+ 		+
    +
  • IoULoss
    • +
  • mmdet loss
    • +
+ 		+
    +
+
+ +
+ +## ❓ FAQ [🔝](#-table-of-contents) + +Please refer to the [FAQ](docs/en/tutorials/faq.md) for frequently asked questions. + +## 🙌 Contributing [🔝](#-table-of-contents) + +We appreciate all contributions to improving MMYOLO. Ongoing projects can be found in our [GitHub Projects](https://github.com/open-mmlab/mmyolo/projects). Welcome community users to participate in these projects. Please refer to [CONTRIBUTING.md](.github/CONTRIBUTING.md) for the contributing guideline. + +## 🤝 Acknowledgement [🔝](#-table-of-contents) + +MMYOLO is an open source project that is contributed by researchers and engineers from various colleges and companies. We appreciate all the contributors who implement their methods or add new features, as well as users who give valuable feedback. +We wish that the toolbox and benchmark could serve the growing research community by providing a flexible toolkit to re-implement existing methods and develop their own new detectors. + +
+ +
+ +## 🖊️ Citation [🔝](#-table-of-contents) + +If you find this project useful in your research, please consider citing: + +```latex +@misc{mmyolo2022, + title={{MMYOLO: OpenMMLab YOLO} series toolbox and benchmark}, + author={MMYOLO Contributors}, + howpublished = {\url{https://github.com/open-mmlab/mmyolo}}, + year={2022} +} +``` + +## 🎫 License [🔝](#-table-of-contents) + +This project is released under the [GPL 3.0 license](LICENSE). + +## 🏗️ Projects in OpenMMLab [🔝](#-table-of-contents) + +- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab foundational library for training deep learning models. +- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab foundational library for computer vision. +- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab pre-training toolbox and benchmark. +- [MMagic](https://github.com/open-mmlab/mmagic): Open**MM**Lab **A**dvanced, **G**enerative and **I**ntelligent **C**reation toolbox. +- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab detection toolbox and benchmark. +- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection. +- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab rotated object detection toolbox and benchmark. +- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO series toolbox and benchmark. +- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab semantic segmentation toolbox and benchmark. +- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab text detection, recognition, and understanding toolbox. +- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab pose estimation toolbox and benchmark. +- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 3D human parametric model toolbox and benchmark. +- [MMSelfSup](https://github.com/open-mmlab/mmselfsup): OpenMMLab self-supervised learning toolbox and benchmark. +- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab model compression toolbox and benchmark. +- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab fewshot learning toolbox and benchmark. +- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab's next-generation action understanding toolbox and benchmark. +- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab video perception toolbox and benchmark. +- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab optical flow toolbox and benchmark. +- [MMEditing](https://github.com/open-mmlab/mmediting): OpenMMLab image and video editing toolbox. +- [MMGeneration](https://github.com/open-mmlab/mmgeneration): OpenMMLab image and video generative models toolbox. +- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab model deployment framework. +- [MIM](https://github.com/open-mmlab/mim): MIM installs OpenMMLab packages. +- [MMEval](https://github.com/open-mmlab/mmeval): OpenMMLab machine learning evaluation library. +- [Playground](https://github.com/open-mmlab/playground): A central hub for gathering and showcasing amazing projects built upon OpenMMLab. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/README_zh-CN.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/README_zh-CN.md new file mode 100644 index 0000000000000000000000000000000000000000..6eb4d95fe5c6d013d677482762d722b20ce826f0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/README_zh-CN.md @@ -0,0 +1,468 @@ +
+ +
 
+
+ OpenMMLab 官网 + + + HOT + + +      + OpenMMLab 开放平台 + + + TRY IT OUT + + +
+
 
+ +[![PyPI](https://img.shields.io/pypi/v/mmyolo)](https://pypi.org/project/mmyolo) +[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmyolo.readthedocs.io/zh_CN/latest/) +[![deploy](https://github.com/open-mmlab/mmyolo/workflows/deploy/badge.svg)](https://github.com/open-mmlab/mmyolo/actions) +[![codecov](https://codecov.io/gh/open-mmlab/mmyolo/branch/main/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmyolo) +[![license](https://img.shields.io/github/license/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/blob/main/LICENSE) +[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues) +[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues) + +[📘使用文档](https://mmyolo.readthedocs.io/zh_CN/latest/) | +[🛠️安装教程](https://mmyolo.readthedocs.io/zh_CN/latest/get_started/installation.html) | +[👀模型库](https://mmyolo.readthedocs.io/zh_CN/latest/model_zoo.html) | +[🆕更新日志](https://mmyolo.readthedocs.io/zh_CN/latest/notes/changelog.html) | +[🤔报告问题](https://github.com/open-mmlab/mmyolo/issues/new/choose) + +
+ +
+ +[English](README.md) | 简体中文 + +
+ +
+ + + + + + + + + + + + + + + + + +
+ +## 📄 Table of Contents + +- [🥳 🚀 最新进展](#--最新进展-) + - [✨ 亮点](#-亮点-) +- [📖 简介](#-简介-) +- [🛠️ 安装](#️%EF%B8%8F-安装-) +- [👨‍🏫 教程](#-教程-) +- [📊 基准测试和模型库](#-基准测试和模型库-) +- [❓ 常见问题](#-常见问题-) +- [🙌 贡献指南](#-贡献指南-) +- [🤝 致谢](#🤝-致谢-) +- [🖊️ 引用](#️-引用-) +- [🎫 开源许可证](#-开源许可证-) +- [🏗️ OpenMMLab 的其他项目](#%EF%B8%8F-openmmlab-的其他项目-) +- [❤️ 欢迎加入 OpenMMLab 社区](#%EF%B8%8F-欢迎加入-openmmlab-社区-) + +## 🥳 🚀 最新进展 [🔝](#-table-of-contents) + +💎 **v0.6.0** 版本已经在 2023.8.15 发布： + +- 支持 YOLOv5 实例分割 +- 基于 MMPose 支持 YOLOX-Pose +- 添加 15 分钟的实例分割教程 +- YOLOv5 支持使用 mask 标注来优化边界框 +- 添加多尺度训练和测试文档 + +我们提供了实用的**脚本命令速查表** + +
+ +
+ +你可以点击[链接](https://pan.baidu.com/s/1QEaqT7YayUdEvh1an0gjHg?pwd=yolo)，下载高清版 PDF 文件。 + +同时我们也推出了解读视频： + +| | 内容 | 视频 | 课程中的代码 | +| :-: | :--------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| 🌟 | 特征图可视化 | [![Link](https://i2.hdslb.com/bfs/archive/480a0eb41fce26e0acb65f82a74501418eee1032.jpg@112w_63h_1c.webp)](https://www.bilibili.com/video/BV188411s7o8) [![bilibili](https://img.shields.io/badge/dynamic/json?label=views&style=social&logo=bilibili&query=data.stat.view&url=https%3A%2F%2Fapi.bilibili.com%2Fx%2Fweb-interface%2Fview%3Fbvid%3DBV188411s7o8)](https://www.bilibili.com/video/BV188411s7o8) | [特征图可视化.ipynb](https://github.com/open-mmlab/OpenMMLabCourse/blob/main/codes/MMYOLO_tutorials/%5B%E5%B7%A5%E5%85%B7%E7%B1%BB%E7%AC%AC%E4%B8%80%E6%9C%9F%5D%E7%89%B9%E5%BE%81%E5%9B%BE%E5%8F%AF%E8%A7%86%E5%8C%96.ipynb) | +| 🌟 | 源码阅读和调试「必备」技巧 | [![Link](https://i2.hdslb.com/bfs/archive/790d2422c879ff20488910da1c4422b667ea6af7.jpg@112w_63h_1c.webp)](https://www.bilibili.com/video/BV1N14y1V7mB) [![bilibili](https://img.shields.io/badge/dynamic/json?label=views&style=social&logo=bilibili&query=data.stat.view&url=https%3A%2F%2Fapi.bilibili.com%2Fx%2Fweb-interface%2Fview%3Fbvid%3DBV1N14y1V7mB)](https://www.bilibili.com/video/BV1N14y1V7mB) | [源码阅读和调试「必备」技巧文档](https://zhuanlan.zhihu.com/p/580885852) | +| 🌟 | 10分钟换遍主干网络 | [![Link](http://i0.hdslb.com/bfs/archive/c51f1aef7c605856777249a7b4478f44bd69f3bd.jpg@112w_63h_1c.webp)](https://www.bilibili.com/video/BV1JG4y1d7GC) [![bilibili](https://img.shields.io/badge/dynamic/json?label=views&style=social&logo=bilibili&query=data.stat.view&url=https%3A%2F%2Fapi.bilibili.com%2Fx%2Fweb-interface%2Fview%3Fbvid%3DBV1JG4y1d7GC)](https://www.bilibili.com/video/BV1JG4y1d7GC) | [10分钟换遍主干网络文档](https://zhuanlan.zhihu.com/p/585641598)
[10分钟换遍主干网络.ipynb](https://github.com/open-mmlab/OpenMMLabCourse/blob/main/codes/MMYOLO_tutorials/[实用类第二期]10分钟换遍主干网络.ipynb) | +| 🌟 | 自定义数据集从标注到部署保姆级教程 | [![Link](https://i2.hdslb.com/bfs/archive/13f566c89a18c9c881713b63ec14da952d4c0b14.jpg@112w_63h_1c.webp)](https://www.bilibili.com/video/BV1RG4y137i5) [![bilibili](https://img.shields.io/badge/dynamic/json?label=views&style=social&logo=bilibili&query=data.stat.view&url=https%3A%2F%2Fapi.bilibili.com%2Fx%2Fweb-interface%2Fview%3Fbvid%3DBV1RG4y137i5)](https://www.bilibili.com/video/BV1JG4y1d7GC) | [自定义数据集从标注到部署保姆级教程](https://github.com/open-mmlab/mmyolo/blob/dev/docs/zh_cn/user_guides/custom_dataset.md) | +| 🌟 | 顶会第一步 · 模块自定义 | [![Link](http://i2.hdslb.com/bfs/archive/5b23d41ac57466824eaf185ef806ef734414e93b.jpg@112w_63h_1c.webp)](https://www.bilibili.com/video/BV1yd4y1j7VD) [![bilibili](https://img.shields.io/badge/dynamic/json?label=views&style=social&logo=bilibili&query=data.stat.view&url=https%3A%2F%2Fapi.bilibili.com%2Fx%2Fweb-interface%2Fview%3Fbvid%3DBV1yd4y1j7VD)](https://www.bilibili.com/video/BV1yd4y1j7VD) | [顶会第一步·模块自定义.ipynb](https://github.com/open-mmlab/OpenMMLabCourse/blob/main/codes/MMYOLO_tutorials/[实用类第四期]顶会第一步·模块自定义.ipynb) | + +完整视频列表请参考 [中文解读资源汇总 - 视频](https://mmyolo.readthedocs.io/zh_CN/latest/get_started/article.html) + +发布历史和更新细节请参考 [更新日志](https://mmyolo.readthedocs.io/zh_CN/latest/notes/changelog.html) + +### ✨ 亮点 [🔝](#-table-of-contents) + +我们很高兴向大家介绍我们在实时目标识别任务方面的最新成果 RTMDet，包含了一系列的全卷积单阶段检测模型。 RTMDet 不仅在从 tiny 到 extra-large 尺寸的目标检测模型上实现了最佳的参数量和精度的平衡，而且在实时实例分割和旋转目标检测任务上取得了最先进的成果。 更多细节请参阅[技术报告](https://arxiv.org/abs/2212.07784)。 预训练模型可以在[这里](configs/rtmdet)找到。 + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + +| Task | Dataset | AP | FPS(TRT FP16 BS1 3090) | +| ------------------------ | ------- | ------------------------------------ | ---------------------- | +| Object Detection | COCO | 52.8 | 322 | +| Instance Segmentation | COCO | 44.6 | 188 | +| Rotated Object Detection | DOTA | 78.9(single-scale)/81.3(multi-scale) | 121 | + +
+ +
+ +MMYOLO 中目前实现了目标检测和旋转框目标检测算法，但是相比 MMDeteciton 版本有显著训练加速，训练速度相比原先版本提升 2.6 倍。 + +## 📖 简介 [🔝](#-table-of-contents) + +MMYOLO 是一个基于 PyTorch 和 MMDetection 的 YOLO 系列算法开源工具箱。它是 [OpenMMLab](https://openmmlab.com/) 项目的一部分。 + +主分支代码目前支持 PyTorch 1.6 以上的版本。 + + +
+主要特性 + +- 🕹️ **统一便捷的算法评测** + + MMYOLO 统一了各类 YOLO 算法模块的实现, 并提供了统一的评测流程，用户可以公平便捷地进行对比分析。 + +- 📚 **丰富的入门和进阶文档** + + MMYOLO 提供了从入门到部署到进阶和算法解析等一系列文档，方便不同用户快速上手和扩展。 + +- 🧩 **模块化设计** + + MMYOLO 将框架解耦成不同的模块组件，通过组合不同的模块和训练测试策略，用户可以便捷地构建自定义模型。 + +基类-P5 + 图为 RangeKing@GitHub 提供，非常感谢！ + +P6 模型图详见 [model_design.md](docs/zh_cn/recommended_topics/model_design.md)。 + +
+ +## 🛠️ 安装 [🔝](#-table-of-contents) + +MMYOLO 依赖 PyTorch, MMCV, MMEngine 和 MMDetection，以下是安装的简要步骤。 更详细的安装指南请参考[安装文档](docs/zh_cn/get_started/installation.md)。 + +```shell +conda create -n mmyolo python=3.8 pytorch==1.10.1 torchvision==0.11.2 cudatoolkit=11.3 -c pytorch -y +conda activate mmyolo +pip install openmim +mim install "mmengine>=0.6.0" +mim install "mmcv>=2.0.0rc4,<2.1.0" +mim install "mmdet>=3.0.0,<4.0.0" +git clone https://github.com/open-mmlab/mmyolo.git +cd mmyolo +# Install albumentations +pip install -r requirements/albu.txt +# Install MMYOLO +mim install -v -e . +``` + +## 👨‍🏫 教程 [🔝](#-table-of-contents) + +MMYOLO 基于 MMDetection 开源库，并且采用相同的代码组织和设计方式。为了更好的使用本开源库，请先阅读 [MMDetection 概述](https://mmdetection.readthedocs.io/zh_CN/latest/get_started.html) 对 MMDetection 进行初步地了解。 + +MMYOLO 用法和 MMDetection 几乎一致，所有教程都是通用的，你也可以了解 [MMDetection 用户指南和进阶指南](https://mmdetection.readthedocs.io/zh_CN/3.x/) 。 + +针对和 MMDetection 不同的部分，我们也准备了用户指南和进阶指南，请阅读我们的 [文档](https://mmyolo.readthedocs.io/zh_CN/latest/) 。 + +
+开启 MMYOLO 之旅 + +- [概述](docs/zh_cn/get_started/overview.md) +- [依赖](docs/zh_cn/get_started/dependencies.md) +- [安装和验证](docs/zh_cn/get_started/installation.md) +- [15 分钟上手 MMYOLO 目标检测](docs/zh_cn/get_started/15_minutes_object_detection.md) +- [15 分钟上手 MMYOLO 旋转框目标检测](docs/zh_cn/get_started/15_minutes_rotated_object_detection.md) +- [15 分钟上手 MMYOLO 实例分割](docs/zh_cn/get_started/15_minutes_instance_segmentation.md) +- [中文解读资源汇总](docs/zh_cn/get_started/article.md) + +
+ +
+推荐专题 + +- [如何给 MMYOLO 贡献代码](docs/zh_cn/recommended_topics/contributing.md) +- [训练和测试技巧](docs/zh_cn/recommended_topics/training_testing_tricks.md) +- [MMYOLO 模型结构设计](docs/zh_cn/recommended_topics/model_design.md) +- [原理和实现全解析](docs/zh_cn/recommended_topics/algorithm_descriptions/) +- [轻松更换主干网络](docs/zh_cn/recommended_topics/replace_backbone.md) +- [MMYOLO 模型复杂度分析](docs/zh_cn/recommended_topics/complexity_analysis.md) +- [标注+训练+测试+部署全流程](docs/zh_cn/recommended_topics/labeling_to_deployment_tutorials.md) +- [关于可视化的一切](docs/zh_cn/recommended_topics/visualization.md) +- [模型部署流程](docs/zh_cn/recommended_topics/deploy/) +- [常见错误排查步骤](docs/zh_cn/recommended_topics/troubleshooting_steps.md) +- [MMYOLO 应用范例介绍](docs/zh_cn/recommended_topics/application_examples/) +- [MM 系列 Repo 必备基础](docs/zh_cn/recommended_topics/mm_basics.md) +- [数据集准备和说明](docs/zh_cn/recommended_topics/dataset_preparation.md) + +
+ +
+常用功能 + +- [恢复训练](docs/zh_cn/common_usage/resume_training.md) +- [开启和关闭 SyncBatchNorm](docs/zh_cn/common_usage/syncbn.md) +- [开启混合精度训练](docs/zh_cn/common_usage/amp_training.md) +- [多尺度训练和测试](docs/zh_cn/common_usage/ms_training_testing.md) +- [测试时增强相关说明](docs/zh_cn/common_usage/tta.md) +- [给主干网络增加插件](docs/zh_cn/common_usage/plugins.md) +- [冻结指定网络层权重](docs/zh_cn/common_usage/freeze_layers.md) +- [输出模型预测结果](docs/zh_cn/common_usage/output_predictions.md) +- [设置随机种子](docs/zh_cn/common_usage/set_random_seed.md) +- [算法组合替换教程](docs/zh_cn/common_usage/module_combination.md) +- [使用 mim 跨库调用其他 OpenMMLab 仓库的脚本](docs/zh_cn/common_usage/mim_usage.md) +- [应用多个 Neck](docs/zh_cn/common_usage/multi_necks.md) +- [指定特定设备训练或推理](docs/zh_cn/common_usage/specify_device.md) +- [单通道和多通道应用案例](docs/zh_cn/common_usage/single_multi_channel_applications.md) +- [MM 系列开源库注册表](docs/zh_cn/common_usage/registries_info.md) + +
+ +
+实用工具 + +- [可视化 COCO 标签](docs/zh_cn/useful_tools/browse_coco_json.md) +- [可视化数据集](docs/zh_cn/useful_tools/browse_dataset.md) +- [打印完整配置文件](docs/zh_cn/useful_tools/print_config.md) +- [可视化数据集分析结果](docs/zh_cn/useful_tools/dataset_analysis.md) +- [优化锚框尺寸](docs/zh_cn/useful_tools/optimize_anchors.md) +- [提取 COCO 子集](docs/zh_cn/useful_tools/extract_subcoco.md) +- [可视化优化器参数策略](docs/zh_cn/useful_tools/vis_scheduler.md) +- [数据集转换](docs/zh_cn/useful_tools/dataset_converters.md) +- [数据集下载](docs/zh_cn/useful_tools/download_dataset.md) +- [日志分析](docs/zh_cn/useful_tools/log_analysis.md) +- [模型转换](docs/zh_cn/useful_tools/model_converters.md) + +
+ +
+基础教程 + +- [学习 YOLOv5 配置文件](docs/zh_cn/tutorials/config.md) +- [数据流](docs/zh_cn/tutorials/data_flow.md) +- [旋转目标检测](docs/zh_cn/tutorials/rotated_detection.md) +- [自定义安装](docs/zh_cn/tutorials/custom_installation.md) +- [常见警告说明](docs/zh_cn/tutorials/warning_notes.md) +- [常见问题](docs/zh_cn/tutorials/faq.md) + +
+ +
+进阶教程 + +- [MMYOLO 跨库应用解析](docs/zh_cn/advanced_guides/cross-library_application.md) + +
+ +
+说明 + +- [更新日志](docs/zh_cn/notes/changelog.md) +- [兼容性说明](docs/zh_cn/notes/compatibility.md) +- [默认约定](docs/zh_cn/notes/conventions.md) +- [代码规范](docs/zh_cn/notes/code_style.md) + +
+ +## 📊 基准测试和模型库 [🔝](#-table-of-contents) + +
+ +
+ +测试结果和模型可以在 [模型库](docs/zh_cn/model_zoo.md) 中找到。 + +
+支持的任务 + +- [x] 目标检测 +- [x] 旋转框目标检测 + +
+ +
+支持的算法 + +- [x] [YOLOv5](configs/yolov5) +- [ ] [YOLOv5u](configs/yolov5/yolov5u) (仅推理) +- [x] [YOLOX](configs/yolox) +- [x] [RTMDet](configs/rtmdet) +- [x] [RTMDet-Rotated](configs/rtmdet) +- [x] [YOLOv6](configs/yolov6) +- [x] [YOLOv7](configs/yolov7) +- [x] [PPYOLOE](configs/ppyoloe) +- [x] [YOLOv8](configs/yolov8) + +
+ +
+支持的数据集 + +- [x] COCO Dataset +- [x] VOC Dataset +- [x] CrowdHuman Dataset +- [x] DOTA 1.0 Dataset + +
+ +
+
+ 模块组件 +
+ + + + + + + + + + + + + + + + + +
+ Backbones + + Necks + + Loss + + Common +
+
    +
  • YOLOv5CSPDarknet
    • +
  • YOLOv8CSPDarknet
    • +
  • YOLOXCSPDarknet
    • +
  • EfficientRep
    • +
  • CSPNeXt
    • +
  • YOLOv7Backbone
    • +
  • PPYOLOECSPResNet
    • +
  • mmdet backbone
    • +
  • mmcls backbone
    • +
  • timm
    • +
+ 		+
    +
  • YOLOv5PAFPN
    • +
  • YOLOv8PAFPN
    • +
  • YOLOv6RepPAFPN
    • +
  • YOLOXPAFPN
    • +
  • CSPNeXtPAFPN
    • +
  • YOLOv7PAFPN
    • +
  • PPYOLOECSPPAFPN
    • +
+ 		+
    +
  • IoULoss
    • +
  • mmdet loss
    • +
+ 		+
    +
+
+ +
+ +## ❓ 常见问题 [🔝](#-table-of-contents) + +请参考 [FAQ](docs/zh_cn/tutorials/faq.md) 了解其他用户的常见问题。 + +## 🙌 贡献指南 [🔝](#-table-of-contents) + +我们感谢所有的贡献者为改进和提升 MMYOLO 所作出的努力。我们将正在进行中的项目添加进了[GitHub Projects](https://github.com/open-mmlab/mmyolo/projects)页面，非常欢迎社区用户能参与进这些项目中来。请参考[贡献指南](.github/CONTRIBUTING.md)来了解参与项目贡献的相关指引。 + +## 🤝 致谢 [🔝](#-table-of-contents) + +MMYOLO 是一款由来自不同高校和企业的研发人员共同参与贡献的开源项目。我们感谢所有为项目提供算法复现和新功能支持的贡献者，以及提供宝贵反馈的用户。 我们希望这个工具箱和基准测试可以为社区提供灵活的代码工具，供用户复现已有算法并开发自己的新模型，从而不断为开源社区提供贡献。 + +
+ +
+ +## 🖊️ 引用 [🔝](#-table-of-contents) + +如果你觉得本项目对你的研究工作有所帮助，请参考如下 bibtex 引用 MMYOLO + +```latex +@misc{mmyolo2022, + title={{MMYOLO: OpenMMLab YOLO} series toolbox and benchmark}, + author={MMYOLO Contributors}, + howpublished = {\url{https://github.com/open-mmlab/mmyolo}}, + year={2022} +} +``` + +## 🎫 开源许可证 [🔝](#-table-of-contents) + +该项目采用 [GPL 3.0 开源许可证](LICENSE)。 + +## 🏗️ OpenMMLab 的其他项目 [🔝](#-table-of-contents) + +- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab 深度学习模型训练基础库 +- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab 计算机视觉基础库 +- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab 深度学习预训练工具箱 +- [MMagic](https://github.com/open-mmlab/mmagic): OpenMMLab 新一代人工智能内容生成（AIGC）工具箱 +- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab 目标检测工具箱 +- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab 新一代通用 3D 目标检测平台 +- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab 旋转框检测工具箱与测试基准 +- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO 系列工具箱 +- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab 语义分割工具箱 +- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab 全流程文字检测识别理解工具包 +- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab 姿态估计工具箱 +- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 人体参数化模型工具箱与测试基准 +- [MMSelfSup](https://github.com/open-mmlab/mmselfsup): OpenMMLab 自监督学习工具箱与测试基准 +- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab 模型压缩工具箱与测试基准 +- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab 少样本学习工具箱与测试基准 +- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab 新一代视频理解工具箱 +- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab 一体化视频目标感知平台 +- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab 光流估计工具箱与测试基准 +- [MMEditing](https://github.com/open-mmlab/mmediting): OpenMMLab 图像视频编辑工具箱 +- [MMGeneration](https://github.com/open-mmlab/mmgeneration): OpenMMLab 图片视频生成模型工具箱 +- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab 模型部署框架 +- [MIM](https://github.com/open-mmlab/mim): MIM 是 OpenMMlab 项目、算法、模型的统一入口 +- [MMEval](https://github.com/open-mmlab/mmeval): OpenMMLab 机器学习算法评测库 +- [Playground](https://github.com/open-mmlab/playground): 收集和展示 OpenMMLab 相关的前沿、有趣的社区项目 + +## ❤️ 欢迎加入 OpenMMLab 社区 [🔝](#-table-of-contents) + +扫描下方的二维码可关注 OpenMMLab 团队的 [知乎官方账号](https://www.zhihu.com/people/openmmlab)，加入 OpenMMLab 团队的 [官方交流 QQ 群](https://jq.qq.com/?_wv=1027&k=aCvMxdr3) + +
+ +
+ +我们会在 OpenMMLab 社区为大家 + +- 📢 分享 AI 框架的前沿核心技术 +- 💻 解读 PyTorch 常用模块源码 +- 📰 发布 OpenMMLab 的相关新闻 +- 🚀 介绍 OpenMMLab 开发的前沿算法 +- 🏃 获取更高效的问题答疑和意见反馈 +- 🔥 提供与各行各业开发者充分交流的平台 + +干货满满 📘，等你来撩 💗，OpenMMLab 社区期待您的加入 👬 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/default_runtime.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/default_runtime.py new file mode 100644 index 0000000000000000000000000000000000000000..098f220573cf481056f2f55f0621198270d51c49 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/default_runtime.py @@ -0,0 +1,43 @@ +default_scope = 'mmyolo' + +default_hooks = dict( + timer=dict(type='IterTimerHook'), + logger=dict(type='LoggerHook', interval=50), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict(type='CheckpointHook', interval=1), + sampler_seed=dict(type='DistSamplerSeedHook'), + visualization=dict(type='mmdet.DetVisualizationHook')) + +env_cfg = dict( + cudnn_benchmark=False, + mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0), + dist_cfg=dict(backend='nccl'), +) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='mmdet.DetLocalVisualizer', + vis_backends=vis_backends, + name='visualizer') +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True) + +log_level = 'INFO' +load_from = None +resume = False + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions +# before MMDet 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) + +backend_args = None diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/det_p5_tta.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/det_p5_tta.py new file mode 100644 index 0000000000000000000000000000000000000000..8df0d5ea8db46fe748cc8fe1074aa928c64b4309 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/det_p5_tta.py @@ -0,0 +1,58 @@ +# TODO: Need to solve the problem of multiple backend_args parameters +# _backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) + +_backend_args = None + +tta_model = dict( + type='mmdet.DetTTAModel', + tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.65), max_per_img=300)) + +img_scales = [(640, 640), (320, 320), (960, 960)] + +# LoadImageFromFile +# / | \ +# (RatioResize,LetterResize) (RatioResize,LetterResize) (RatioResize,LetterResize) # noqa +# / \ / \ / \ +# RandomFlip RandomFlip RandomFlip RandomFlip RandomFlip RandomFlip # noqa +# | | | | | | +# LoadAnn LoadAnn LoadAnn LoadAnn LoadAnn LoadAnn +# | | | | | | +# PackDetIn PackDetIn PackDetIn PackDetIn PackDetIn PackDetIn # noqa + +_multiscale_resize_transforms = [ + dict( + type='Compose', + transforms=[ + dict(type='YOLOv5KeepRatioResize', scale=s), + dict( + type='LetterResize', + scale=s, + allow_scale_up=False, + pad_val=dict(img=114)) + ]) for s in img_scales +] + +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_backend_args), + dict( + type='TestTimeAug', + transforms=[ + _multiscale_resize_transforms, + [ + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'flip', + 'flip_direction')) + ] + ]) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/pose/coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/pose/coco.py new file mode 100644 index 0000000000000000000000000000000000000000..865a95bc02fedd318f32d2e7aa8397147d78fdb5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/_base_/pose/coco.py @@ -0,0 +1,181 @@ +dataset_info = dict( + dataset_name='coco', + paper_info=dict( + author='Lin, Tsung-Yi and Maire, Michael and ' + 'Belongie, Serge and Hays, James and ' + 'Perona, Pietro and Ramanan, Deva and ' + r'Doll{\'a}r, Piotr and Zitnick, C Lawrence', + title='Microsoft coco: Common objects in context', + container='European conference on computer vision', + year='2014', + homepage='http://cocodataset.org/', + ), + keypoint_info={ + 0: + dict(name='nose', id=0, color=[51, 153, 255], type='upper', swap=''), + 1: + dict( + name='left_eye', + id=1, + color=[51, 153, 255], + type='upper', + swap='right_eye'), + 2: + dict( + name='right_eye', + id=2, + color=[51, 153, 255], + type='upper', + swap='left_eye'), + 3: + dict( + name='left_ear', + id=3, + color=[51, 153, 255], + type='upper', + swap='right_ear'), + 4: + dict( + name='right_ear', + id=4, + color=[51, 153, 255], + type='upper', + swap='left_ear'), + 5: + dict( + name='left_shoulder', + id=5, + color=[0, 255, 0], + type='upper', + swap='right_shoulder'), + 6: + dict( + name='right_shoulder', + id=6, + color=[255, 128, 0], + type='upper', + swap='left_shoulder'), + 7: + dict( + name='left_elbow', + id=7, + color=[0, 255, 0], + type='upper', + swap='right_elbow'), + 8: + dict( + name='right_elbow', + id=8, + color=[255, 128, 0], + type='upper', + swap='left_elbow'), + 9: + dict( + name='left_wrist', + id=9, + color=[0, 255, 0], + type='upper', + swap='right_wrist'), + 10: + dict( + name='right_wrist', + id=10, + color=[255, 128, 0], + type='upper', + swap='left_wrist'), + 11: + dict( + name='left_hip', + id=11, + color=[0, 255, 0], + type='lower', + swap='right_hip'), + 12: + dict( + name='right_hip', + id=12, + color=[255, 128, 0], + type='lower', + swap='left_hip'), + 13: + dict( + name='left_knee', + id=13, + color=[0, 255, 0], + type='lower', + swap='right_knee'), + 14: + dict( + name='right_knee', + id=14, + color=[255, 128, 0], + type='lower', + swap='left_knee'), + 15: + dict( + name='left_ankle', + id=15, + color=[0, 255, 0], + type='lower', + swap='right_ankle'), + 16: + dict( + name='right_ankle', + id=16, + color=[255, 128, 0], + type='lower', + swap='left_ankle') + }, + skeleton_info={ + 0: + dict(link=('left_ankle', 'left_knee'), id=0, color=[0, 255, 0]), + 1: + dict(link=('left_knee', 'left_hip'), id=1, color=[0, 255, 0]), + 2: + dict(link=('right_ankle', 'right_knee'), id=2, color=[255, 128, 0]), + 3: + dict(link=('right_knee', 'right_hip'), id=3, color=[255, 128, 0]), + 4: + dict(link=('left_hip', 'right_hip'), id=4, color=[51, 153, 255]), + 5: + dict(link=('left_shoulder', 'left_hip'), id=5, color=[51, 153, 255]), + 6: + dict(link=('right_shoulder', 'right_hip'), id=6, color=[51, 153, 255]), + 7: + dict( + link=('left_shoulder', 'right_shoulder'), + id=7, + color=[51, 153, 255]), + 8: + dict(link=('left_shoulder', 'left_elbow'), id=8, color=[0, 255, 0]), + 9: + dict( + link=('right_shoulder', 'right_elbow'), id=9, color=[255, 128, 0]), + 10: + dict(link=('left_elbow', 'left_wrist'), id=10, color=[0, 255, 0]), + 11: + dict(link=('right_elbow', 'right_wrist'), id=11, color=[255, 128, 0]), + 12: + dict(link=('left_eye', 'right_eye'), id=12, color=[51, 153, 255]), + 13: + dict(link=('nose', 'left_eye'), id=13, color=[51, 153, 255]), + 14: + dict(link=('nose', 'right_eye'), id=14, color=[51, 153, 255]), + 15: + dict(link=('left_eye', 'left_ear'), id=15, color=[51, 153, 255]), + 16: + dict(link=('right_eye', 'right_ear'), id=16, color=[51, 153, 255]), + 17: + dict(link=('left_ear', 'left_shoulder'), id=17, color=[51, 153, 255]), + 18: + dict( + link=('right_ear', 'right_shoulder'), id=18, color=[51, 153, 255]) + }, + joint_weights=[ + 1., 1., 1., 1., 1., 1., 1., 1.2, 1.2, 1.5, 1.5, 1., 1., 1.2, 1.2, 1.5, + 1.5 + ], + sigmas=[ + 0.026, 0.025, 0.025, 0.035, 0.035, 0.079, 0.079, 0.072, 0.072, 0.062, + 0.062, 0.107, 0.107, 0.087, 0.087, 0.089, 0.089 + ]) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/base_dynamic.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/base_dynamic.py new file mode 100644 index 0000000000000000000000000000000000000000..747c21fd2bf0523c7d1e2ace67cff3f3d6612c2a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/base_dynamic.py @@ -0,0 +1,17 @@ +_base_ = ['./base_static.py'] +onnx_config = dict( + dynamic_axes={ + 'input': { + 0: 'batch', + 2: 'height', + 3: 'width' + }, + 'dets': { + 0: 'batch', + 1: 'num_dets' + }, + 'labels': { + 0: 'batch', + 1: 'num_dets' + } + }) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/base_static.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/base_static.py new file mode 100644 index 0000000000000000000000000000000000000000..dee01dd5dde1185b5e156b036f72fb3ccb0bf5bc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/base_static.py @@ -0,0 +1,23 @@ +onnx_config = dict( + type='onnx', + export_params=True, + keep_initializers_as_inputs=False, + opset_version=11, + save_file='end2end.onnx', + input_names=['input'], + output_names=['dets', 'labels'], + input_shape=None, + optimize=True) +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_onnxruntime_dynamic.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_onnxruntime_dynamic.py new file mode 100644 index 0000000000000000000000000000000000000000..14f4a12115f403fb4d091db9c07f925ba2ad83ec --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_onnxruntime_dynamic.py @@ -0,0 +1,15 @@ +_base_ = ['./base_dynamic.py'] +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +backend_config = dict(type='onnxruntime') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_onnxruntime_static.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_onnxruntime_static.py new file mode 100644 index 0000000000000000000000000000000000000000..3eac8ca75715b711bdf03784dbb977a81bf444d3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_onnxruntime_static.py @@ -0,0 +1,15 @@ +_base_ = ['./base_static.py'] +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +backend_config = dict(type='onnxruntime') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_rknn-fp16_static-320x320.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_rknn-fp16_static-320x320.py new file mode 100644 index 0000000000000000000000000000000000000000..b7bd31331ebae8374dc06f9ed4e0e82a3204e36f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_rknn-fp16_static-320x320.py @@ -0,0 +1,9 @@ +_base_ = ['./base_static.py'] +onnx_config = dict( + input_shape=[320, 320], output_names=['feat0', 'feat1', 'feat2']) +codebase_config = dict(model_type='rknn') +backend_config = dict( + type='rknn', + common_config=dict(target_platform='rv1126', optimization_level=1), + quantization_config=dict(do_quantization=False, dataset=None), + input_size_list=[[3, 320, 320]]) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_rknn-int8_static-320x320.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_rknn-int8_static-320x320.py new file mode 100644 index 0000000000000000000000000000000000000000..10c96b2f26d27be28b384612d9ae8ee2cae84983 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_rknn-int8_static-320x320.py @@ -0,0 +1,9 @@ +_base_ = ['./base_static.py'] +onnx_config = dict( + input_shape=[320, 320], output_names=['feat0', 'feat1', 'feat2']) +codebase_config = dict(model_type='rknn') +backend_config = dict( + type='rknn', + common_config=dict(target_platform='rv1126', optimization_level=1), + quantization_config=dict(do_quantization=True, dataset=None), + input_size_list=[[3, 320, 320]]) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_dynamic-192x192-960x960.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_dynamic-192x192-960x960.py new file mode 100644 index 0000000000000000000000000000000000000000..da565b6c341add02a74579a734eb4cb123847e6d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_dynamic-192x192-960x960.py @@ -0,0 +1,13 @@ +_base_ = ['./base_dynamic.py'] +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=True, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 192, 192], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 960, 960]))) + ]) +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_dynamic-64x64-1344x1344.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_dynamic-64x64-1344x1344.py new file mode 100644 index 0000000000000000000000000000000000000000..bad8521afa6ebd4f9bb24a137b66fd1c66668361 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_dynamic-64x64-1344x1344.py @@ -0,0 +1,13 @@ +_base_ = ['./base_dynamic.py'] +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=True, max_workspace_size=1 << 32), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 64, 64], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 1344, 1344]))) + ]) +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_static-640x640.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_static-640x640.py new file mode 100644 index 0000000000000000000000000000000000000000..24d2a00d9340b2e3cd3392ab2881b68cccd75e8a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-fp16_static-640x640.py @@ -0,0 +1,14 @@ +_base_ = ['./base_static.py'] +onnx_config = dict(input_shape=(640, 640)) +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=True, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 640, 640], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 640, 640]))) + ]) +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-int8_dynamic-192x192-960x960.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-int8_dynamic-192x192-960x960.py new file mode 100644 index 0000000000000000000000000000000000000000..21591c4d4e72a867392adf9c49cd60c6bb994e35 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-int8_dynamic-192x192-960x960.py @@ -0,0 +1,15 @@ +_base_ = ['./base_dynamic.py'] +backend_config = dict( + type='tensorrt', + common_config=dict( + fp16_mode=True, max_workspace_size=1 << 30, int8_mode=True), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 192, 192], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 960, 960]))) + ]) +calib_config = dict(create_calib=True, calib_file='calib_data.h5') +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-int8_static-640x640.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-int8_static-640x640.py new file mode 100644 index 0000000000000000000000000000000000000000..ac394a6b3f854a0d23a1d37ff07d87c523c9784a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt-int8_static-640x640.py @@ -0,0 +1,16 @@ +_base_ = ['./base_static.py'] +onnx_config = dict(input_shape=(640, 640)) +backend_config = dict( + type='tensorrt', + common_config=dict( + fp16_mode=True, max_workspace_size=1 << 30, int8_mode=True), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 640, 640], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 640, 640]))) + ]) +calib_config = dict(create_calib=True, calib_file='calib_data.h5') +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py new file mode 100644 index 0000000000000000000000000000000000000000..17047d7380043da537f2f6029bb4373986062c04 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py @@ -0,0 +1,13 @@ +_base_ = ['./base_dynamic.py'] +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=False, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 192, 192], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 960, 960]))) + ]) +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt_static-640x640.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt_static-640x640.py new file mode 100644 index 0000000000000000000000000000000000000000..9ec49cc114cc0025310766be17bb5c45af56c516 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/detection_tensorrt_static-640x640.py @@ -0,0 +1,14 @@ +_base_ = ['./base_static.py'] +onnx_config = dict(input_shape=(640, 640)) +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=False, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 640, 640], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 640, 640]))) + ]) +use_efficientnms = False # whether to replace TRTBatchedNMS plugin with EfficientNMS plugin # noqa E501 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/model/yolov5_s-static.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/model/yolov5_s-static.py new file mode 100644 index 0000000000000000000000000000000000000000..11b7f6a040271f4c82fce8e8240b23ad54fd18c7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/model/yolov5_s-static.py @@ -0,0 +1,19 @@ +_base_ = '../../yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=False, + use_mini_pad=False, + ), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +test_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/model/yolov6_s-static.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/model/yolov6_s-static.py new file mode 100644 index 0000000000000000000000000000000000000000..4f64438ca3d3ba1699e514bc2c8ee900d5095d4d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/deploy/model/yolov6_s-static.py @@ -0,0 +1,19 @@ +_base_ = '../../yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py' + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=False, + use_mini_pad=False, + ), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +test_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/README.md new file mode 100644 index 0000000000000000000000000000000000000000..70a5b2055bbbc79cc6e4817cc3d936780b09f73e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/README.md @@ -0,0 +1,43 @@ +# PPYOLOE + + + +## Abstract + +PP-YOLOE is an excellent single-stage anchor-free model based on PP-YOLOv2, surpassing a variety of popular YOLO models. PP-YOLOE has a series of models, named s/m/l/x, which are configured through width multiplier and depth multiplier. PP-YOLOE avoids using special operators, such as Deformable Convolution or Matrix NMS, to be deployed friendly on various hardware. + +
+ +
+ +
+ +PPYOLOE-PLUS-l model structure +
+ +## Results and models + +### PPYOLOE+ COCO + +| Backbone | Arch | Size | Epoch | SyncBN | Mem (GB) | Box AP | Config | Download | +| :---------: | :--: | :--: | :---: | :----: | :------: | :----: | :----------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| PPYOLOE+ -s | P5 | 640 | 80 | Yes | 4.7 | 43.5 | [config](./ppyoloe_plus_s_fast_8xb8-80e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco/ppyoloe_plus_s_fast_8xb8-80e_coco_20230101_154052-9fee7619.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco/ppyoloe_plus_s_fast_8xb8-80e_coco_20230101_154052.log.json) | +| PPYOLOE+ -m | P5 | 640 | 80 | Yes | 8.4 | 49.5 | [config](./ppyoloe_plus_m_fast_8xb8-80e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco/ppyoloe_plus_m_fast_8xb8-80e_coco_20230104_193132-e4325ada.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco/ppyoloe_plus_m_fast_8xb8-80e_coco_20230104_193132.log.json) | +| PPYOLOE+ -l | P5 | 640 | 80 | Yes | 13.2 | 52.6 | [config](./ppyoloe_plus_l_fast_8xb8-80e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_l_fast_8xb8-80e_coco/ppyoloe_plus_l_fast_8xb8-80e_coco_20230102_203825-1864e7b3.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_l_fast_8xb8-80e_coco/ppyoloe_plus_l_fast_8xb8-80e_coco_20230102_203825.log.json) | +| PPYOLOE+ -x | P5 | 640 | 80 | Yes | 19.1 | 54.2 | [config](./ppyoloe_plus_x_fast_8xb8-80e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco/ppyoloe_plus_x_fast_8xb8-80e_coco_20230104_194921-8c953949.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco/ppyoloe_plus_x_fast_8xb8-80e_coco_20230104_194921.log.json) | + +**Note**: + +1. The above Box APs are all models with the best performance in COCO +2. The gap between the above performance and the official release is about 0.3. To speed up training in mmyolo, we use pytorch to implement the image resizing in `PPYOLOEBatchRandomResize` for multi-scale training, while official PPYOLOE use opencv. And `lanczos4` is not yet supported in `PPYOLOEBatchRandomResize`. The above two reasons lead to the gap. We will continue to experiment and address the gap in future releases. +3. The mAP of the non-Plus version needs more verification, and we will update more details of the non-Plus version in future versions. + +```latex +@article{Xu2022PPYOLOEAE, + title={PP-YOLOE: An evolved version of YOLO}, + author={Shangliang Xu and Xinxin Wang and Wenyu Lv and Qinyao Chang and Cheng Cui and Kaipeng Deng and Guanzhong Wang and Qingqing Dang and Shengyun Wei and Yuning Du and Baohua Lai}, + journal={ArXiv}, + year={2022}, + volume={abs/2203.16250} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..5b7ed9487b60afecbd9db87f0ad89d9b3be8c93d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/metafile.yml @@ -0,0 +1,69 @@ +Collections: + - Name: PPYOLOE + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - Synchronize BN + Training Resources: 8x A100 GPUs + Architecture: + - PPYOLOECSPResNet + - PPYOLOECSPPAFPN + Paper: + URL: https://arxiv.org/abs/2203.16250 + Title: 'PP-YOLOE: An evolved version of YOLO' + README: configs/ppyoloe/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.0.1/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.0.1 + +Models: + - Name: ppyoloe_plus_s_fast_8xb8-80e_coco + In Collection: PPYOLOE + Config: configs/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco.py + Metadata: + Training Memory (GB): 4.7 + Epochs: 80 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.5 + Weights: https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco/ppyoloe_plus_s_fast_8xb8-80e_coco_20230101_154052-9fee7619.pth + - Name: ppyoloe_plus_m_fast_8xb8-80e_coco + In Collection: PPYOLOE + Config: configs/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco.py + Metadata: + Training Memory (GB): 8.4 + Epochs: 80 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.5 + Weights: https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco/ppyoloe_plus_m_fast_8xb8-80e_coco_20230104_193132-e4325ada.pth + - Name: ppyoloe_plus_L_fast_8xb8-80e_coco + In Collection: PPYOLOE + Config: configs/ppyoloe/ppyoloe_plus_L_fast_8xb8-80e_coco.py + Metadata: + Training Memory (GB): 13.2 + Epochs: 80 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.6 + Weights: https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_l_fast_8xb8-80e_coco/ppyoloe_plus_l_fast_8xb8-80e_coco_20230102_203825-1864e7b3.pth + - Name: ppyoloe_plus_x_fast_8xb8-80e_coco + In Collection: PPYOLOE + Config: configs/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco.py + Metadata: + Training Memory (GB): 19.1 + Epochs: 80 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 54.2 + Weights: https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco/ppyoloe_plus_x_fast_8xb8-80e_coco_20230104_194921-8c953949.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_l_fast_8xb20-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_l_fast_8xb20-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..ef1b4eaae7240e07a5e8450f35b6f71f2271e09f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_l_fast_8xb20-300e_coco.py @@ -0,0 +1,23 @@ +_base_ = './ppyoloe_s_fast_8xb32-300e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +checkpoint = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/cspresnet_l_imagenet1k_pretrained-c0010e6c.pth' # noqa + +deepen_factor = 1.0 +widen_factor = 1.0 + +train_batch_size_per_gpu = 20 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_m_fast_8xb28-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_m_fast_8xb28-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..abcfd7833016164fbef84a70366b958f28ea6648 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_m_fast_8xb28-300e_coco.py @@ -0,0 +1,23 @@ +_base_ = './ppyoloe_s_fast_8xb32-300e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +checkpoint = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/cspresnet_m_imagenet1k_pretrained-09f1eba2.pth' # noqa + +deepen_factor = 0.67 +widen_factor = 0.75 + +train_batch_size_per_gpu = 28 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_l_fast_8xb8-80e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_l_fast_8xb8-80e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..9db53e26f4168e82b6cd760e1b8f41c0bebfae8f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_l_fast_8xb8-80e_coco.py @@ -0,0 +1,16 @@ +_base_ = './ppyoloe_plus_s_fast_8xb8-80e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +load_from = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/ppyoloe_plus_l_obj365_pretrained-3dd89562.pth' # noqa + +deepen_factor = 1.0 +widen_factor = 1.0 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..17cb33556f7ff111a4d702e6798abda1aaafeb01 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_m_fast_8xb8-80e_coco.py @@ -0,0 +1,16 @@ +_base_ = './ppyoloe_plus_s_fast_8xb8-80e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +load_from = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/ppyoloe_plus_m_ojb365_pretrained-03206892.pth' # noqa + +deepen_factor = 0.67 +widen_factor = 0.75 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_s_fast_1xb12-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_s_fast_1xb12-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..752ff63388cee00156dc729b68242eae68e4d052 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_s_fast_1xb12-40e_cat.py @@ -0,0 +1,56 @@ +# Compared to other same scale models, this configuration consumes too much +# GPU memory and is not validated for now +_base_ = 'ppyoloe_plus_s_fast_8xb8-80e_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +num_last_epochs = 5 + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 2 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco/ppyoloe_plus_s_fast_8xb8-80e_coco_20230101_154052-9fee7619.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict(head_module=dict(num_classes=num_classes)), + train_cfg=dict( + initial_assigner=dict(num_classes=num_classes), + assigner=dict(num_classes=num_classes))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +default_hooks = dict( + param_scheduler=dict( + warmup_min_iter=10, + warmup_epochs=3, + total_epochs=int(max_epochs * 1.2))) + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..3d98252ccaec23c75b3e8aa3ddb095ee85010bd8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_s_fast_8xb8-80e_coco.py @@ -0,0 +1,239 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# dataset settings +data_root = 'data/coco/' +dataset_type = 'YOLOv5CocoDataset' + +# parameters that often need to be modified +img_scale = (640, 640) # width, height +deepen_factor = 0.33 +widen_factor = 0.5 +max_epochs = 80 +num_classes = 80 +save_epoch_intervals = 5 +train_batch_size_per_gpu = 8 +train_num_workers = 8 +val_batch_size_per_gpu = 1 +val_num_workers = 2 + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +load_from = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/ppyoloe_plus_s_obj365_pretrained-bcfe8478.pth' # noqa + +# persistent_workers must be False if num_workers is 0. +persistent_workers = True + +# Base learning rate for optim_wrapper +base_lr = 0.001 + +strides = [8, 16, 32] + +model = dict( + type='YOLODetector', + data_preprocessor=dict( + # use this to support multi_scale training + type='PPYOLOEDetDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='PPYOLOEBatchRandomResize', + random_size_range=(320, 800), + interval=1, + size_divisor=32, + random_interp=True, + keep_ratio=False) + ], + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='PPYOLOECSPResNet', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + block_cfg=dict( + type='PPYOLOEBasicBlock', shortcut=True, use_alpha=True), + norm_cfg=dict(type='BN', momentum=0.1, eps=1e-5), + act_cfg=dict(type='SiLU', inplace=True), + attention_cfg=dict( + type='EffectiveSELayer', act_cfg=dict(type='HSigmoid')), + use_large_stem=True), + neck=dict( + type='PPYOLOECSPPAFPN', + in_channels=[256, 512, 1024], + out_channels=[192, 384, 768], + deepen_factor=deepen_factor, + widen_factor=widen_factor, + num_csplayer=1, + num_blocks_per_layer=3, + block_cfg=dict( + type='PPYOLOEBasicBlock', shortcut=False, use_alpha=False), + norm_cfg=dict(type='BN', momentum=0.1, eps=1e-5), + act_cfg=dict(type='SiLU', inplace=True), + drop_block_cfg=None, + use_spp=True), + bbox_head=dict( + type='PPYOLOEHead', + head_module=dict( + type='PPYOLOEHeadModule', + num_classes=num_classes, + in_channels=[192, 384, 768], + widen_factor=widen_factor, + featmap_strides=strides, + reg_max=16, + norm_cfg=dict(type='BN', momentum=0.1, eps=1e-5), + act_cfg=dict(type='SiLU', inplace=True), + num_base_priors=1), + prior_generator=dict( + type='mmdet.MlvlPointGenerator', offset=0.5, strides=strides), + bbox_coder=dict(type='DistancePointBBoxCoder'), + loss_cls=dict( + type='mmdet.VarifocalLoss', + use_sigmoid=True, + alpha=0.75, + gamma=2.0, + iou_weighted=True, + reduction='sum', + loss_weight=1.0), + loss_bbox=dict( + type='IoULoss', + iou_mode='giou', + bbox_format='xyxy', + reduction='mean', + loss_weight=2.5, + return_iou=False), + # Since the dflloss is implemented differently in the official + # and mmdet, we're going to divide loss_weight by 4. + loss_dfl=dict( + type='mmdet.DistributionFocalLoss', + reduction='mean', + loss_weight=0.5 / 4)), + train_cfg=dict( + initial_epoch=30, + initial_assigner=dict( + type='BatchATSSAssigner', + num_classes=num_classes, + topk=9, + iou_calculator=dict(type='mmdet.BboxOverlaps2D')), + assigner=dict( + type='BatchTaskAlignedAssigner', + num_classes=num_classes, + topk=13, + alpha=1, + beta=6, + eps=1e-9)), + test_cfg=dict( + multi_label=True, + nms_pre=1000, + score_thr=0.01, + nms=dict(type='nms', iou_threshold=0.7), + max_per_img=300)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='PPYOLOERandomDistort'), + dict(type='mmdet.Expand', mean=(103.53, 116.28, 123.675)), + dict(type='PPYOLOERandomCrop'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + collate_fn=dict(type='yolov5_collate', use_ms_training=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=0), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='mmdet.FixShapeResize', + width=img_scale[0], + height=img_scale[1], + keep_ratio=False, + interpolation='bicubic'), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img='val2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=0), + ann_file='annotations/instances_val2017.json', + pipeline=test_pipeline)) + +test_dataloader = val_dataloader + +param_scheduler = None +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.9, + weight_decay=5e-4, + nesterov=False), + paramwise_cfg=dict(norm_decay_mult=0.)) + +default_hooks = dict( + param_scheduler=dict( + type='PPYOLOEParamSchedulerHook', + warmup_min_iter=1000, + start_factor=0., + warmup_epochs=5, + min_lr_ratio=0.0, + total_epochs=int(max_epochs * 1.2)), + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + save_best='auto', + max_keep_ckpts=3)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_epoch_intervals) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b8e61120bee63c67da1ae31e492709381b365b47 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_plus_x_fast_8xb8-80e_coco.py @@ -0,0 +1,16 @@ +_base_ = './ppyoloe_plus_s_fast_8xb8-80e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +load_from = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/ppyoloe_plus_x_obj365_pretrained-43a8000d.pth' # noqa + +deepen_factor = 1.33 +widen_factor = 1.25 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_s_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_s_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..622332899cd4f8589559ed3484fb5affb6a7963b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_s_fast_8xb32-300e_coco.py @@ -0,0 +1,36 @@ +_base_ = './ppyoloe_plus_s_fast_8xb8-80e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +checkpoint = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/cspresnet_s_imagenet1k_pretrained-2be81763.pth' # noqa + +train_batch_size_per_gpu = 32 +max_epochs = 300 + +# Base learning rate for optim_wrapper +base_lr = 0.01 + +model = dict( + data_preprocessor=dict( + mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], + std=[0.229 * 255., 0.224 * 255., 0.225 * 255.]), + backbone=dict( + block_cfg=dict(use_alpha=False), + init_cfg=dict( + type='Pretrained', + prefix='backbone.', + checkpoint=checkpoint, + map_location='cpu')), + train_cfg=dict(initial_epoch=100)) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) + +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +default_hooks = dict(param_scheduler=dict(total_epochs=int(max_epochs * 1.2))) + +train_cfg = dict(max_epochs=max_epochs) + +# PPYOLOE plus use obj365 pretrained model, but PPYOLOE not, +# `load_from` need to set to None. +load_from = None diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_s_fast_8xb32-400e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_s_fast_8xb32-400e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..bef9e9130d6194fceeb6471369941050110ace2d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_s_fast_8xb32-400e_coco.py @@ -0,0 +1,9 @@ +_base_ = './ppyoloe_s_fast_8xb32-300e_coco.py' + +max_epochs = 400 + +model = dict(train_cfg=dict(initial_epoch=133)) + +default_hooks = dict(param_scheduler=dict(total_epochs=int(max_epochs * 1.2))) + +train_cfg = dict(max_epochs=max_epochs) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_x_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_x_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..fed594f0d08acf2fa64feffa419d0143d1036c55 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/ppyoloe/ppyoloe_x_fast_8xb16-300e_coco.py @@ -0,0 +1,23 @@ +_base_ = './ppyoloe_s_fast_8xb32-300e_coco.py' + +# The pretrained model is geted and converted from official PPYOLOE. +# https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/configs/ppyoloe/README.md +checkpoint = 'https://download.openmmlab.com/mmyolo/v0/ppyoloe/ppyoloe_pretrain/cspresnet_x_imagenet1k_pretrained-81c33ccb.pth' # noqa + +deepen_factor = 1.33 +widen_factor = 1.25 + +train_batch_size_per_gpu = 16 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/README.md new file mode 100644 index 0000000000000000000000000000000000000000..456021bdd32036a31ca9863194dd74a174fcdd76 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/README.md @@ -0,0 +1,79 @@ +# Projecs Based on MMRazor + +There are many research works and pre-trained models built on MMRazor. We list some of them as examples of how to use MMRazor slimmable models for downstream frameworks. As the page might not be completed, please feel free to contribute more efficient mmrazor-models to update this page. + +## Description + +This is an implementation of MMRazor Searchable Backbone Application, we provide detection configs and models for MMRazor in MMYOLO. + +### Backbone support + +Here are the Neural Architecture Search(NAS) Models that come from MMRazor which support YOLO Series. If you are looking for MMRazor models only for Backbone, you could refer to MMRazor [ModelZoo](https://github.com/open-mmlab/mmrazor/blob/dev-1.x/docs/en/get_started/model_zoo.md) and corresponding repository. + +- [x] [AttentiveMobileNetV3](https://github.com/open-mmlab/mmrazor/blob/dev-1.x/configs/_base_/nas_backbones/attentive_mobilenetv3_supernet.py) +- [x] [SearchableShuffleNetV2](https://github.com/open-mmlab/mmrazor/blob/dev-1.x/configs/_base_/nas_backbones/spos_shufflenet_supernet.py) +- [x] [SearchableMobileNetV2](https://github.com/open-mmlab/mmrazor/blob/dev-1.x/configs/_base_/nas_backbones/spos_mobilenet_supernet.py) + +## Usage + +### Prerequisites + +- [MMRazor v1.0.0rc2](https://github.com/open-mmlab/mmrazor/tree/v1.0.0rc2) or higher (dev-1.x) + +Install MMRazor using MIM. + +```shell +mim install mmengine +mim install "mmrazor>=1.0.0rc2" +``` + +Install MMRazor from source + +``` +git clone -b dev-1.x https://github.com/open-mmlab/mmrazor.git +cd mmrazor +# Install MMRazor +mim install -v -e . +``` + +### Training commands + +In MMYOLO's root directory, if you want to use single GPU for training, run the following command to train the model: + +```bash +CUDA_VISIBLE_DEVICES=0 PORT=29500 ./tools/dist_train.sh configs/razor/subnets/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py +``` + +If you want to use several of these GPUs to train in parallel, you can use the following command: + +```bash +CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 PORT=29500 ./tools/dist_train.sh configs/razor/subnets/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py +``` + +### Testing commands + +In MMYOLO's root directory, run the following command to test the model: + +```bash +CUDA_VISIBLE_DEVICES=0 PORT=29500 ./tools/dist_test.sh configs/razor/subnets/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py ${CHECKPOINT_PATH} +``` + +## Results and Models + +Here we provide the baseline version of YOLO Series with NAS backbone. + +| Model | size | box AP | Params(M) | FLOPs(G) | Config | Download | +| :------------------------: | :--: | :----: | :----------: | :------: | :---------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| yolov5-s | 640 | 37.7 | 7.235 | 8.265 | [config](../../yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json) | +| yolov5_s_spos_shufflenetv2 | 640 | 38.0 | 7.04(-2.7%) | 7.03 | [config](./yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/yolo_nas_backbone/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco_20230211_220635-578be9a9.pth) \| log | +| yolov6-s | 640 | 44.0 | 18.869 | 24.253 | [config](../../yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035-932e1d91.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035.log.json) | +| yolov6_l_attentivenas_a6 | 640 | 45.3 | 18.38(-2.6%) | 8.49 | [config](./yolov6_l_attentivenas_a6_d12_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/yolo_nas_backbone/yolov6_l_attentivenas_a6_d12_syncbn_fast_8xb32-300e_coco_20230211_222409-dcc72668.pth) \| log | +| RTMDet-tiny | 640 | 41.0 | 4.8 | 8.1 | [config](../../rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco/rtmdet_tiny_syncbn_fast_8xb32-300e_coco_20230102_140117-dbb1dc83.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco/rtmdet_tiny_syncbn_fast_8xb32-300e_coco_20230102_140117.log.json) | +| rtmdet_tiny_ofa_lat31 | 960 | 41.3 | 3.91(-18.5%) | 6.09 | [config](./rtmdet_tiny_ofa_lat31_syncbn_16xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/yolo_nas_backbone/rtmdet_tiny_ofa_lat31_syncbn_16xb16-300e_coco_20230214_210623-449bb2a0.pth) \| log | + +**Note**: + +1. For fair comparison, the training configuration is consistent with the original configuration and results in an improvement of about 0.2-0.5% AP. +2. `yolov5_s_spos_shufflenetv2` achieves 38.0% AP with only 7.042M parameters, directly instead of the backbone, and outperforms `yolov5_s` with a similar size by more than 0.3% AP. +3. With the efficient backbone of `yolov6_l_attentivenas_a6`, the input channels of `YOLOv6RepPAFPN` are reduced. Meanwhile, modify the **deepen_factor** and the neck is made deeper to restore the AP. +4. with the `rtmdet_tiny_ofa_lat31` backbone with only 3.315M parameters and 3.634G flops, we can modify the input resolution to 960, with a similar model size compared to `rtmdet_tiny` and exceeds `rtmdet_tiny` by 0.4% AP, reducing the size of the whole model to 3.91 MB. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/rtmdet_tiny_ofa_lat31_syncbn_16xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/rtmdet_tiny_ofa_lat31_syncbn_16xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..2f9da6685ef0ef920ceb137a165dfb8adcd36254 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/rtmdet_tiny_ofa_lat31_syncbn_16xb16-300e_coco.py @@ -0,0 +1,124 @@ +_base_ = [ + 'mmrazor::_base_/nas_backbones/ofa_mobilenetv3_supernet.py', + '../../rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py' +] + +checkpoint_file = 'https://download.openmmlab.com/mmrazor/v1/ofa/ofa_mobilenet_subnet_8xb256_in1k_note8_lat%4031ms_top1%4072.8_finetune%4025.py_20221214_0939-981a8b2a.pth' # noqa +fix_subnet = 'https://download.openmmlab.com/mmrazor/v1/yolo_nas_backbone/OFA_SUBNET_NOTE8_LAT31.yaml' # noqa +deepen_factor = 0.167 +widen_factor = 1.0 +channels = [40, 112, 160] +train_batch_size_per_gpu = 16 +img_scale = (960, 960) + +_base_.nas_backbone.out_indices = (2, 4, 5) +_base_.nas_backbone.conv_cfg = dict(type='mmrazor.OFAConv2d') +_base_.nas_backbone.init_cfg = dict( + type='Pretrained', + checkpoint=checkpoint_file, + prefix='architecture.backbone.') +nas_backbone = dict( + type='mmrazor.sub_model', + fix_subnet=fix_subnet, + cfg=_base_.nas_backbone, + extra_prefix='backbone.') + +_base_.model.backbone = nas_backbone +_base_.model.neck.widen_factor = widen_factor +_base_.model.neck.deepen_factor = deepen_factor +_base_.model.neck.in_channels = channels +_base_.model.neck.out_channels = channels[0] +_base_.model.bbox_head.head_module.in_channels = channels[0] +_base_.model.bbox_head.head_module.feat_channels = channels[0] +_base_.model.bbox_head.head_module.widen_factor = widen_factor + +_base_.model.test_cfg = dict( + multi_label=True, + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Mosaic', + img_scale=img_scale, + use_cached=True, + max_cached_images=20, + random_pop=False, + pad_val=114.0), + dict( + type='mmdet.RandomResize', + scale=(1280, 1280), + ratio_range=(0.5, 2.0), # note + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='YOLOXMixUp', + img_scale=(960, 960), + ratio_range=(1.0, 1.0), + max_cached_images=10, + use_cached=True, + random_pop=False, + pad_val=(114, 114, 114), + prob=0.5), + dict(type='mmdet.PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='mmdet.RandomResize', + scale=img_scale, + ratio_range=(0.5, 2.0), # note + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict(type='mmdet.PackDetInputs') +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, dataset=dict(pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=(960, 960), keep_ratio=True), + dict(type='mmdet.Pad', size=(960, 960), pad_val=dict(img=(114, 114, 114))), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) + +test_dataloader = val_dataloader + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=_base_.max_epochs - _base_.num_epochs_stage2, + switch_pipeline=train_pipeline_stage2) +] + +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..beb4941cfa482ec52e83abc67df70d9734fa3d3a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/yolov5_s_spos_shufflenetv2_syncbn_8xb16-300e_coco.py @@ -0,0 +1,29 @@ +_base_ = [ + 'mmrazor::_base_/nas_backbones/spos_shufflenet_supernet.py', + '../../yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' +] + +checkpoint_file = 'https://download.openmmlab.com/mmrazor/v1/spos/spos_shufflenetv2_subnet_8xb128_in1k_flops_0.33M_acc_73.87_20211222-1f0a0b4d_v3.pth' # noqa +fix_subnet = 'https://download.openmmlab.com/mmrazor/v1/spos/spos_shufflenetv2_subnet_8xb128_in1k_flops_0.33M_acc_73.87_20211222-1f0a0b4d_subnet_cfg_v3.yaml' # noqa +widen_factor = 1.0 +channels = [160, 320, 640] + +_base_.nas_backbone.out_indices = (1, 2, 3) +_base_.nas_backbone.init_cfg = dict( + type='Pretrained', + checkpoint=checkpoint_file, + prefix='architecture.backbone.') +nas_backbone = dict( + type='mmrazor.sub_model', + fix_subnet=fix_subnet, + cfg=_base_.nas_backbone, + extra_prefix='architecture.backbone.') + +_base_.model.backbone = nas_backbone +_base_.model.neck.widen_factor = widen_factor +_base_.model.neck.in_channels = channels +_base_.model.neck.out_channels = channels +_base_.model.bbox_head.head_module.in_channels = channels +_base_.model.bbox_head.head_module.widen_factor = widen_factor + +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/yolov6_l_attentivenas_a6_d12_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/yolov6_l_attentivenas_a6_d12_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..0ab64a6460b3fbb29cc1a47a1bd1a2456bb11ac3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/razor/subnets/yolov6_l_attentivenas_a6_d12_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,35 @@ +_base_ = [ + 'mmrazor::_base_/nas_backbones/attentive_mobilenetv3_supernet.py', + '../../yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco.py' +] + +checkpoint_file = 'https://download.openmmlab.com/mmrazor/v1/bignas/attentive_mobilenet_subnet_8xb256_in1k_flops-0.93G_acc-80.81_20221229_200440-73d92cc6.pth' # noqa +fix_subnet = 'https://download.openmmlab.com/mmrazor/v1/bignas/ATTENTIVE_SUBNET_A6.yaml' # noqa +deepen_factor = 1.2 +widen_factor = 1 +channels = [40, 128, 224] +mid_channels = [40, 128, 224] + +_base_.train_dataloader.batch_size = 16 +_base_.nas_backbone.out_indices = (2, 4, 6) +_base_.nas_backbone.conv_cfg = dict(type='mmrazor.BigNasConv2d') +_base_.nas_backbone.norm_cfg = dict(type='mmrazor.DynamicBatchNorm2d') +_base_.nas_backbone.init_cfg = dict( + type='Pretrained', + checkpoint=checkpoint_file, + prefix='architecture.backbone.') +nas_backbone = dict( + type='mmrazor.sub_model', + fix_subnet=fix_subnet, + cfg=_base_.nas_backbone, + extra_prefix='backbone.') + +_base_.model.backbone = nas_backbone +_base_.model.neck.widen_factor = widen_factor +_base_.model.neck.deepen_factor = deepen_factor +_base_.model.neck.in_channels = channels +_base_.model.neck.out_channels = mid_channels +_base_.model.bbox_head.head_module.in_channels = mid_channels +_base_.model.bbox_head.head_module.widen_factor = widen_factor + +find_unused_parameters = True diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/README.md new file mode 100644 index 0000000000000000000000000000000000000000..94e86546a34c3d70da4b51d81ff46e8ee7d5f242 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/README.md @@ -0,0 +1,83 @@ +# RTMDet: An Empirical Study of Designing Real-Time Object Detectors + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + + + +## Abstract + +In this paper, we aim to design an efficient real-time object detector that exceeds the YOLO series and is easily extensible for many object recognition tasks such as instance segmentation and rotated object detection. To obtain a more efficient model architecture, we explore an architecture that has compatible capacities in the backbone and neck, constructed by a basic building block that consists of large-kernel depth-wise convolutions. We further introduce soft labels when calculating matching costs in the dynamic label assignment to improve accuracy. Together with better training techniques, the resulting object detector, named RTMDet, achieves 52.8% AP on COCO with 300+ FPS on an NVIDIA 3090 GPU, outperforming the current mainstream industrial detectors. RTMDet achieves the best parameter-accuracy trade-off with tiny/small/medium/large/extra-large model sizes for various application scenarios, and obtains new state-of-the-art performance on real-time instance segmentation and rotated object detection. We hope the experimental results can provide new insights into designing versatile real-time object detectors for many object recognition tasks. + +
+ +
+ +
+ +RTMDet-l model structure +
+ +## Results and Models + +### Object Detection + +| Model | size | Params(M) | FLOPs(G) | TRT-FP16-Latency(ms) | box AP | TTA box AP | Config | Download | +| :------------: | :--: | :-------: | :------: | :------------------: | :---------: | :---------: | :---------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| RTMDet-tiny | 640 | 4.8 | 8.1 | 0.98 | 41.0 | 42.7 | [config](./rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco/rtmdet_tiny_syncbn_fast_8xb32-300e_coco_20230102_140117-dbb1dc83.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco/rtmdet_tiny_syncbn_fast_8xb32-300e_coco_20230102_140117.log.json) | +| RTMDet-tiny \* | 640 | 4.8 | 8.1 | 0.98 | 41.8 (+0.8) | 43.2 (+0.5) | [config](./distillation/kd_tiny_rtmdet_s_neck_300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_tiny_rtmdet_s_neck_300e_coco/kd_tiny_rtmdet_s_neck_300e_coco_20230213_104240-e1e4197c.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_tiny_rtmdet_s_neck_300e_coco/kd_tiny_rtmdet_s_neck_300e_coco_20230213_104240-176901d8.json) | +| RTMDet-s | 640 | 8.89 | 14.8 | 1.22 | 44.6 | 45.8 | [config](./rtmdet_s_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco/rtmdet_s_syncbn_fast_8xb32-300e_coco_20221230_182329-0a8c901a.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco/rtmdet_s_syncbn_fast_8xb32-300e_coco_20221230_182329.log.json) | +| RTMDet-s \* | 640 | 8.89 | 14.8 | 1.22 | 45.7 (+1.1) | 47.3 (+1.5) | [config](./distillation/kd_s_rtmdet_m_neck_300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_s_rtmdet_m_neck_300e_coco/kd_s_rtmdet_m_neck_300e_coco_20230220_140647-446ff003.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_s_rtmdet_m_neck_300e_coco/kd_s_rtmdet_m_neck_300e_coco_20230220_140647-89862269.json) | +| RTMDet-m | 640 | 24.71 | 39.27 | 1.62 | 49.3 | 50.9 | [config](./rtmdet_m_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco/rtmdet_m_syncbn_fast_8xb32-300e_coco_20230102_135952-40af4fe8.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco/rtmdet_m_syncbn_fast_8xb32-300e_coco_20230102_135952.log.json) | +| RTMDet-m \* | 640 | 24.71 | 39.27 | 1.62 | 50.2 (+0.9) | 51.9 (+1.0) | [config](./distillation/kd_m_rtmdet_l_neck_300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_m_rtmdet_l_neck_300e_coco/kd_m_rtmdet_l_neck_300e_coco_20230220_141313-b806f503.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_m_rtmdet_l_neck_300e_coco/kd_m_rtmdet_l_neck_300e_coco_20230220_141313-bd028fd3.json) | +| RTMDet-l | 640 | 52.3 | 80.23 | 2.44 | 51.4 | 53.1 | [config](./rtmdet_l_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco/rtmdet_l_syncbn_fast_8xb32-300e_coco_20230102_135928-ee3abdc4.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco/rtmdet_l_syncbn_fast_8xb32-300e_coco_20230102_135928.log.json) | +| RTMDet-l \* | 640 | 52.3 | 80.23 | 2.44 | 52.3 (+0.9) | 53.7 (+0.6) | [config](./distillation/kd_l_rtmdet_x_neck_300e_coco.py) | [model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_l_rtmdet_x_neck_300e_coco/kd_l_rtmdet_x_neck_300e_coco_20230220_141912-c9979722.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_l_rtmdet_x_neck_300e_coco/kd_l_rtmdet_x_neck_300e_coco_20230220_141912-c5c4e17b.json) | +| RTMDet-x | 640 | 94.86 | 141.67 | 3.10 | 52.8 | 54.2 | [config](./rtmdet_x_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco/rtmdet_x_syncbn_fast_8xb32-300e_coco_20221231_100345-b85cd476.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco/rtmdet_x_syncbn_fast_8xb32-300e_coco_20221231_100345.log.json) | + +**Note**: + +1. The inference speed of RTMDet is measured on an NVIDIA 3090 GPU with TensorRT 8.4.3, cuDNN 8.2.0, FP16, batch size=1, and without NMS. +2. For a fair comparison, the config of bbox postprocessing is changed to be consistent with YOLOv5/6/7 after [PR#9494](https://github.com/open-mmlab/mmdetection/pull/9494), bringing about 0.1~0.3% AP improvement. +3. `TTA` means that Test Time Augmentation. It's perform 3 multi-scaling transformations on the image, followed by 2 flipping transformations (flipping and not flipping). You only need to specify `--tta` when testing to enable. see [TTA](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/common_usage/tta.md) for details. +4. \* means checkpoints are trained with knowledge distillation. More details can be found in [RTMDet distillation](./distillation). + +### Rotated Object Detection + +RTMDet-R achieves state-of-the-art on various remote sensing datasets. + +| Backbone | pretrain | Epoch | Batch Size | Aug | mmAP | mAP50 | mAP75 | Mem (GB) | Params(M) | FLOPS(G) | TRT-FP16-Latency(ms) | Config | Download | +| :---------: | :------: | :---: | :--------: | :-------------: | :---: | :---: | :---: | :------: | :-------: | :------: | :------------------: | :--------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| RTMDet-tiny | IN | 36 | 1xb8 | RR | 46.94 | 75.07 | 50.11 | 12.7 | 4.88 | 20.45 | 4.40 | [config](./rotated/rtmdet-r_tiny_fast_1xb8-36e_dota.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota/rtmdet-r_tiny_fast_1xb8-36e_dota_20230228_162210-e8ccfb1c.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota/rtmdet-r_tiny_fast_1xb8-36e_dota_20230228_162210.log.json) | +| RTMDet-s | IN | 36 | 1xb8 | RR | 48.99 | 77.33 | 52.65 | 16.6 | 8.86 | 37.62 | 4.86 | [config](./rotated/rtmdet-r_s_fast_1xb8-36e_dota.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota/rtmdet-r_s_fast_1xb8-36e_dota_20230224_110307-3946a5aa.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota/rtmdet-r_s_fast_1xb8-36e_dota_20230224_110307.log.json) | +| RTMDet-m | IN | 36 | 2xb4 | RR | 50.38 | 78.43 | 54.28 | 10.9 | 24.67 | 99.76 | 7.82 | [config](./rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota/rtmdet-r_m_syncbn_fast_2xb4-36e_dota_20230224_124237-29ae1619.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota/rtmdet-r_m_syncbn_fast_2xb4-36e_dota_20230224_124237.log.json) | +| RTMDet-l | IN | 36 | 2xb4 | RR | 50.61 | 78.66 | 54.95 | 16.1 | 52.27 | 204.21 | 10.82 | [config](./rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota/rtmdet-r_l_syncbn_fast_2xb4-36e_dota_20230224_124544-38bc5f08.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota/rtmdet-r_l_syncbn_fast_2xb4-36e_dota_20230224_124544.log.json) | +| RTMDet-tiny | IN | 36 | 1xb8 | MS+RR | - | - | - | | 4.88 | 20.45 | 4.40 | [config](./rotated/rtmdet-r_tiny_fast_1xb8-36e_dota-ms.py) | \| | +| RTMDet-s | IN | 36 | 1xb8 | MS+RR | - | - | - | | 8.86 | 37.62 | 4.86 | [config](./rotated/rtmdet-r_s_fast_1xb8-36e_dota-ms.py) | \| | +| RTMDet-m | IN | 36 | 2xb4 | MS+RR | - | - | - | | 24.67 | 99.76 | 7.82 | [config](./rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota-ms.py) | \| | +| RTMDet-l | IN | 36 | 2xb4 | MS+RR | - | - | - | | 52.27 | 204.21 | 10.82 | [config](./rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py) | \| | +| RTMDet-l | COCO | 36 | 2xb4 | MS+RR | - | - | - | | 52.27 | 204.21 | 10.82 | [config](./rotated/rtmdet-r_l_syncbn_fast_coco-pretrain_2xb4-36e_dota-ms.py) | \| | +| RTMDet-l | IN | 100 | 2xb4 | Mixup+Mosaic+RR | 55.05 | 80.14 | 61.32 | 19.6 | 52.27 | 204.21 | 10.82 | [config](./rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota.py) | [model](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota_20230224_124735-ed4ea966.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota_20230224_124735.log.json) | + +**Note**: + +1. Please follow doc to get start with rotated detection. [Rotated Object Detection](../../docs/zh_cn/tutorials/rotated_detection.md) +2. We follow the latest metrics from the DOTA evaluation server, original voc format mAP is now mAP50. +3. All models trained with image size 1024\*1024. +4. `IN` means ImageNet pretrain, `COCO` means COCO pretrain. +5. For Aug, RR means `RandomRotate`, MS means multi-scale augmentation in data prepare. +6. The inference speed here is measured on an NVIDIA 2080Ti GPU with TensorRT 8.4.3, cuDNN 8.2.0, FP16, batch size=1, and with NMS. +7. Currently, the training process of RTMDet-R tiny is unstable and may have 1% accuracy fluctuation, we will continue to investigate why. + +## Citation + +```latex +@misc{lyu2022rtmdet, + title={RTMDet: An Empirical Study of Designing Real-Time Object Detectors}, + author={Chengqi Lyu and Wenwei Zhang and Haian Huang and Yue Zhou and Yudong Wang and Yanyi Liu and Shilong Zhang and Kai Chen}, + year={2022}, + eprint={2212.07784}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2db5a50ec5ed0d3b499ca7d3c83bc4963c95af3f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/README.md @@ -0,0 +1,53 @@ +# CSPNeXt ImageNet Pre-training + +In this folder, we provide the imagenet pre-training config of RTMDet's backbone CSPNeXt. + +## Requirements + +To train with these configs, please install [MMClassification 1.x](https://github.com/open-mmlab/mmclassification/tree/1.x) first. + +Install by MIM: + +```shell +mim install mmcls>=1.0.0rc0 +``` + +or install by pip: + +```shell +pip install mmcls>=1.0.0rc0 +``` + +## Prepare Dataset + +To pre-train on ImageNet, you need to prepare the dataset first. Please refer to the [guide](https://mmclassification.readthedocs.io/en/1.x/user_guides/dataset_prepare.html#imagenet). + +## How to Train + +You can use the classification config in the same way as the detection config. + +For single-GPU training, run: + +```shell +python tools/train.py \ + ${CONFIG_FILE} \ + [optional arguments] +``` + +For multi-GPU training, run: + +```shell +bash ./tools/dist_train.sh \ + ${CONFIG_FILE} \ + ${GPU_NUM} \ + [optional arguments] +``` + +More details can be found in [user guides](https://mmdetection.readthedocs.io/en/3.x/user_guides/train.html). + +## Results and Models + +| Model | resolution | Params(M) | Flops(G) | Top-1 (%) | Top-5 (%) | Download | +| :----------: | :--------: | :-------: | :------: | :-------: | :-------: | :-----------------------------------------------------------------------------------------------------------------: | +| CSPNeXt-tiny | 224x224 | 2.73 | 0.339 | 69.44 | 89.45 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth) | +| CSPNeXt-s | 224x224 | 4.89 | 0.664 | 74.41 | 92.23 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth) | diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/cspnext-s_8xb256-rsb-a1-600e_in1k.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/cspnext-s_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 0000000000000000000000000000000000000000..4281f9cd7d260f22d7b0e8d18d2c4f56866ad840 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/cspnext-s_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,67 @@ +_base_ = [ + 'mmcls::_base_/datasets/imagenet_bs256_rsb_a12.py', + 'mmcls::_base_/schedules/imagenet_bs2048_rsb.py', + 'mmcls::_base_/default_runtime.py' +] + +custom_imports = dict( + imports=['mmdet.models', 'mmyolo.models'], allow_failed_imports=False) + +model = dict( + type='ImageClassifier', + backbone=dict( + type='mmyolo.CSPNeXt', + arch='P5', + out_indices=(4, ), + expand_ratio=0.5, + deepen_factor=0.33, + widen_factor=0.5, + channel_attention=True, + norm_cfg=dict(type='BN'), + act_cfg=dict(type='mmyolo.SiLU')), + neck=dict(type='GlobalAveragePooling'), + head=dict( + type='LinearClsHead', + num_classes=1000, + in_channels=512, + loss=dict( + type='LabelSmoothLoss', + label_smooth_val=0.1, + mode='original', + loss_weight=1.0), + topk=(1, 5)), + train_cfg=dict(augments=[ + dict(type='Mixup', alpha=0.2, num_classes=1000), + dict(type='CutMix', alpha=1.0, num_classes=1000) + ])) + +# dataset settings +train_dataloader = dict(sampler=dict(type='RepeatAugSampler', shuffle=True)) + +# schedule settings +optim_wrapper = dict( + optimizer=dict(weight_decay=0.01), + paramwise_cfg=dict(bias_decay_mult=0., norm_decay_mult=0.), +) + +param_scheduler = [ + # warm up learning rate scheduler + dict( + type='LinearLR', + start_factor=0.0001, + by_epoch=True, + begin=0, + end=5, + # update by iter + convert_to_iter_based=True), + # main learning rate scheduler + dict( + type='CosineAnnealingLR', + T_max=595, + eta_min=1.0e-6, + by_epoch=True, + begin=5, + end=600) +] + +train_cfg = dict(by_epoch=True, max_epochs=600) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/cspnext-tiny_8xb256-rsb-a1-600e_in1k.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/cspnext-tiny_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 0000000000000000000000000000000000000000..af3170bdc51778c4601d4426aa88cc27c608f100 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/cspnext_imagenet_pretrain/cspnext-tiny_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,5 @@ +_base_ = './cspnext-s_8xb256-rsb-a1-600e_in1k.py' + +model = dict( + backbone=dict(deepen_factor=0.167, widen_factor=0.375), + head=dict(in_channels=384)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..452a46cb9904a1782c0fee9cd7d469c0749caadb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/README.md @@ -0,0 +1,146 @@ +# Distill RTM Detectors Based on MMRazor + +## Description + +To further improve the model accuracy while not introducing much additional +computation cost, we apply the feature-based distillation to the training phase +of these RTM detectors. In summary, our distillation strategy are threefold: + +(1) Inspired by [PKD](https://arxiv.org/abs/2207.02039), we first normalize +the intermediate feature maps to have zero mean and unit variances before calculating +the distillation loss. + +(2) Inspired by [CWD](https://arxiv.org/abs/2011.13256), we adopt the channel-wise +distillation paradigm, which can pay more attention to the most salient regions +of each channel. + +(3) Inspired by [DAMO-YOLO](https://arxiv.org/abs/2211.15444), the distillation +process is split into two stages. 1) The teacher distills the student at the +first stage (280 epochs) on strong mosaic domain. 2) The student finetunes itself +on no masaic domain at the second stage (20 epochs). + +## Results and Models + +| Location | Dataset | Teacher | Student | mAP | mAP(T) | mAP(S) | Config | Download | +| :------: | :-----: | :---------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------: | :---------: | :----: | :----: | :------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| FPN | COCO | [RTMDet-s](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py) | [RTMDet-tiny](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py) | 41.8 (+0.8) | 44.6 | 41.0 | [config](kd_tiny_rtmdet_s_neck_300e_coco.py) | [teacher](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco/rtmdet_s_syncbn_fast_8xb32-300e_coco_20221230_182329-0a8c901a.pth) \|[model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_tiny_rtmdet_s_neck_300e_coco/kd_tiny_rtmdet_s_neck_300e_coco_20230213_104240-e1e4197c.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_tiny_rtmdet_s_neck_300e_coco/kd_tiny_rtmdet_s_neck_300e_coco_20230213_104240-176901d8.json) | +| FPN | COCO | [RTMDet-m](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py) | [RTMDet-s](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py) | 45.7 (+1.1) | 49.3 | 44.6 | [config](kd_s_rtmdet_m_neck_300e_coco.py) | [teacher](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco/rtmdet_m_syncbn_fast_8xb32-300e_coco_20230102_135952-40af4fe8.pth) \|[model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_s_rtmdet_m_neck_300e_coco/kd_s_rtmdet_m_neck_300e_coco_20230220_140647-446ff003.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_s_rtmdet_m_neck_300e_coco/kd_s_rtmdet_m_neck_300e_coco_20230220_140647-89862269.json) | +| FPN | COCO | [RTMDet-l](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py) | [RTMDet-m](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py) | 50.2 (+0.9) | 51.4 | 49.3 | [config](kd_m_rtmdet_l_neck_300e_coco.py) | [teacher](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco/rtmdet_l_syncbn_fast_8xb32-300e_coco_20230102_135928-ee3abdc4.pth) \|[model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_m_rtmdet_l_neck_300e_coco/kd_m_rtmdet_l_neck_300e_coco_20230220_141313-b806f503.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_m_rtmdet_l_neck_300e_coco/kd_m_rtmdet_l_neck_300e_coco_20230220_141313-bd028fd3.json) | +| FPN | COCO | [RTMDet-x](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco.py) | [RTMDet-l](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py) | 52.3 (+0.9) | 52.8 | 51.4 | [config](kd_l_rtmdet_x_neck_300e_coco.py) | [teacher](https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco/rtmdet_x_syncbn_fast_8xb32-300e_coco_20221231_100345-b85cd476.pth) \|[model](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_l_rtmdet_x_neck_300e_coco/kd_l_rtmdet_x_neck_300e_coco_20230220_141912-c9979722.pth) \| [log](https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_l_rtmdet_x_neck_300e_coco/kd_l_rtmdet_x_neck_300e_coco_20230220_141912-c5c4e17b.json) | + +## Usage + +### Prerequisites + +- [MMRazor dev-1.x](https://github.com/open-mmlab/mmrazor/tree/dev-1.x) + +Install MMRazor from source + +``` +git clone -b dev-1.x https://github.com/open-mmlab/mmrazor.git +cd mmrazor +# Install MMRazor +mim install -v -e . +``` + +### Training commands + +In MMYOLO's root directory, run the following command to train the RTMDet-tiny +with 8 GPUs, using RTMDet-s as the teacher: + +```bash +CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 PORT=29500 ./tools/dist_train.sh configs/rtmdet/distillation/kd_tiny_rtmdet_s_neck_300e_coco.py +``` + +### Testing commands + +In MMYOLO's root directory, run the following command to test the model: + +```bash +CUDA_VISIBLE_DEVICES=0 PORT=29500 ./tools/dist_test.sh configs/rtmdet/distillation/kd_tiny_rtmdet_s_neck_300e_coco.py ${CHECKPOINT_PATH} +``` + +### Getting student-only checkpoint + +After training, the checkpoint contains parameters for both student and teacher models. +Run the following command to convert it to student-only checkpoint: + +```bash +python ./tools/model_converters/convert_kd_ckpt_to_student.py ${CHECKPOINT_PATH} --out-path ${OUTPUT_CHECKPOINT_PATH} +``` + +## Configs + +Here we provide detection configs and models for MMRazor in MMYOLO. For clarify, +we take `./kd_tiny_rtmdet_s_neck_300e_coco.py` as an example to show how to +distill a RTM detector based on MMRazor. + +Here is the main part of `./kd_tiny_rtmdet_s_neck_300e_coco.py`. + +```shell +norm_cfg = dict(type='BN', affine=False, track_running_stats=False) + +distiller=dict( + type='ConfigurableDistiller', + student_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv'), + ), + teacher_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv')), + connectors=dict( + fpn0_s=dict(type='ConvModuleConnector', in_channel=96, + out_channel=128, bias=False, norm_cfg=norm_cfg, + act_cfg=None), + fpn0_t=dict( + type='NormConnector', in_channels=128, norm_cfg=norm_cfg), + fpn1_s=dict( + type='ConvModuleConnector', in_channel=96, + out_channel=128, bias=False, norm_cfg=norm_cfg, + act_cfg=None), + fpn1_t=dict( + type='NormConnector', in_channels=128, norm_cfg=norm_cfg), + fpn2_s=dict( + type='ConvModuleConnector', in_channel=96, + out_channel=128, bias=False, norm_cfg=norm_cfg, + act_cfg=None), + fpn2_t=dict( + type='NormConnector', in_channels=128, norm_cfg=norm_cfg)), + distill_losses=dict( + loss_fpn0=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn1=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn2=dict(type='ChannelWiseDivergence', loss_weight=1)), + loss_forward_mappings=dict( + loss_fpn0=dict( + preds_S=dict(from_student=True, recorder='fpn0', connector='fpn0_s'), + preds_T=dict(from_student=False, recorder='fpn0', connector='fpn0_t')), + loss_fpn1=dict( + preds_S=dict(from_student=True, recorder='fpn1', connector='fpn1_s'), + preds_T=dict(from_student=False, recorder='fpn1', connector='fpn1_t')), + loss_fpn2=dict( + preds_S=dict(from_student=True, recorder='fpn2', connector='fpn2_s'), + preds_T=dict(from_student=False, recorder='fpn2', connector='fpn2_t')))) + +``` + +`recorders` are used to record various intermediate results during the model forward. +In this example, they can help record the output of 3 `nn.Module` of the teacher +and the student. Details are list in [Recorder](https://github.com/open-mmlab/mmrazor/blob/dev-1.x/docs/en/advanced_guides/recorder.md) and [MMRazor Distillation](https://zhuanlan.zhihu.com/p/596582609) (if users can read Chinese). + +`connectors` are adaptive layers which usually map teacher's and students features +to the same dimension. + +`distill_losses` are configs for multiple distill losses. + +`loss_forward_mappings` are mappings between distill loss forward arguments and records. + +In addition, the student finetunes itself on no masaic domain at the last 20 epochs, +so we add a new hook named `StopDistillHook` to stop distillation on time. +We need to add this hook to the `custom_hooks` list like this: + +```shell +custom_hooks = [..., dict(type='mmrazor.StopDistillHook', detach_epoch=280)] +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_l_rtmdet_x_neck_300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_l_rtmdet_x_neck_300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..2bab26a0d20342c38d7d1ec0a8221fdc426f016b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_l_rtmdet_x_neck_300e_coco.py @@ -0,0 +1,99 @@ +_base_ = '../rtmdet_l_syncbn_fast_8xb32-300e_coco.py' + +teacher_ckpt = 'https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco/rtmdet_x_syncbn_fast_8xb32-300e_coco_20221231_100345-b85cd476.pth' # noqa: E501 + +norm_cfg = dict(type='BN', affine=False, track_running_stats=False) + +model = dict( + _delete_=True, + _scope_='mmrazor', + type='FpnTeacherDistill', + architecture=dict( + cfg_path='mmyolo::rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py'), + teacher=dict( + cfg_path='mmyolo::rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco.py'), + teacher_ckpt=teacher_ckpt, + distiller=dict( + type='ConfigurableDistiller', + # `recorders` are used to record various intermediate results during + # the model forward. + student_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv'), + ), + teacher_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv')), + # `connectors` are adaptive layers which usually map teacher's and + # students features to the same dimension. + connectors=dict( + fpn0_s=dict( + type='ConvModuleConnector', + in_channel=256, + out_channel=320, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn0_t=dict( + type='NormConnector', in_channels=320, norm_cfg=norm_cfg), + fpn1_s=dict( + type='ConvModuleConnector', + in_channel=256, + out_channel=320, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn1_t=dict( + type='NormConnector', in_channels=320, norm_cfg=norm_cfg), + fpn2_s=dict( + type='ConvModuleConnector', + in_channel=256, + out_channel=320, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn2_t=dict( + type='NormConnector', in_channels=320, norm_cfg=norm_cfg)), + distill_losses=dict( + loss_fpn0=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn1=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn2=dict(type='ChannelWiseDivergence', loss_weight=1)), + # `loss_forward_mappings` are mappings between distill loss forward + # arguments and records. + loss_forward_mappings=dict( + loss_fpn0=dict( + preds_S=dict( + from_student=True, recorder='fpn0', connector='fpn0_s'), + preds_T=dict( + from_student=False, recorder='fpn0', connector='fpn0_t')), + loss_fpn1=dict( + preds_S=dict( + from_student=True, recorder='fpn1', connector='fpn1_s'), + preds_T=dict( + from_student=False, recorder='fpn1', connector='fpn1_t')), + loss_fpn2=dict( + preds_S=dict( + from_student=True, recorder='fpn2', connector='fpn2_s'), + preds_T=dict( + from_student=False, recorder='fpn2', + connector='fpn2_t'))))) + +find_unused_parameters = True + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=_base_.max_epochs - _base_.num_epochs_stage2, + switch_pipeline=_base_.train_pipeline_stage2), + # stop distillation after the 280th epoch + dict(type='mmrazor.StopDistillHook', stop_epoch=280) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_m_rtmdet_l_neck_300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_m_rtmdet_l_neck_300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..f7d7f9211f1f77c4d83677f7f6c485a5c6212252 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_m_rtmdet_l_neck_300e_coco.py @@ -0,0 +1,99 @@ +_base_ = '../rtmdet_m_syncbn_fast_8xb32-300e_coco.py' + +teacher_ckpt = 'https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco/rtmdet_l_syncbn_fast_8xb32-300e_coco_20230102_135928-ee3abdc4.pth' # noqa: E501 + +norm_cfg = dict(type='BN', affine=False, track_running_stats=False) + +model = dict( + _delete_=True, + _scope_='mmrazor', + type='FpnTeacherDistill', + architecture=dict( + cfg_path='mmyolo::rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py'), + teacher=dict( + cfg_path='mmyolo::rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py'), + teacher_ckpt=teacher_ckpt, + distiller=dict( + type='ConfigurableDistiller', + # `recorders` are used to record various intermediate results during + # the model forward. + student_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv'), + ), + teacher_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv')), + # `connectors` are adaptive layers which usually map teacher's and + # students features to the same dimension. + connectors=dict( + fpn0_s=dict( + type='ConvModuleConnector', + in_channel=192, + out_channel=256, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn0_t=dict( + type='NormConnector', in_channels=256, norm_cfg=norm_cfg), + fpn1_s=dict( + type='ConvModuleConnector', + in_channel=192, + out_channel=256, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn1_t=dict( + type='NormConnector', in_channels=256, norm_cfg=norm_cfg), + fpn2_s=dict( + type='ConvModuleConnector', + in_channel=192, + out_channel=256, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn2_t=dict( + type='NormConnector', in_channels=256, norm_cfg=norm_cfg)), + distill_losses=dict( + loss_fpn0=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn1=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn2=dict(type='ChannelWiseDivergence', loss_weight=1)), + # `loss_forward_mappings` are mappings between distill loss forward + # arguments and records. + loss_forward_mappings=dict( + loss_fpn0=dict( + preds_S=dict( + from_student=True, recorder='fpn0', connector='fpn0_s'), + preds_T=dict( + from_student=False, recorder='fpn0', connector='fpn0_t')), + loss_fpn1=dict( + preds_S=dict( + from_student=True, recorder='fpn1', connector='fpn1_s'), + preds_T=dict( + from_student=False, recorder='fpn1', connector='fpn1_t')), + loss_fpn2=dict( + preds_S=dict( + from_student=True, recorder='fpn2', connector='fpn2_s'), + preds_T=dict( + from_student=False, recorder='fpn2', + connector='fpn2_t'))))) + +find_unused_parameters = True + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=_base_.max_epochs - _base_.num_epochs_stage2, + switch_pipeline=_base_.train_pipeline_stage2), + # stop distillation after the 280th epoch + dict(type='mmrazor.StopDistillHook', stop_epoch=280) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_s_rtmdet_m_neck_300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_s_rtmdet_m_neck_300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..99b5dc5e48d04fed927cbd80c1538ca99912fc1b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_s_rtmdet_m_neck_300e_coco.py @@ -0,0 +1,99 @@ +_base_ = '../rtmdet_s_syncbn_fast_8xb32-300e_coco.py' + +teacher_ckpt = 'https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco/rtmdet_m_syncbn_fast_8xb32-300e_coco_20230102_135952-40af4fe8.pth' # noqa: E501 + +norm_cfg = dict(type='BN', affine=False, track_running_stats=False) + +model = dict( + _delete_=True, + _scope_='mmrazor', + type='FpnTeacherDistill', + architecture=dict( + cfg_path='mmyolo::rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py'), + teacher=dict( + cfg_path='mmyolo::rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py'), + teacher_ckpt=teacher_ckpt, + distiller=dict( + type='ConfigurableDistiller', + # `recorders` are used to record various intermediate results during + # the model forward. + student_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv'), + ), + teacher_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv')), + # `connectors` are adaptive layers which usually map teacher's and + # students features to the same dimension. + connectors=dict( + fpn0_s=dict( + type='ConvModuleConnector', + in_channel=128, + out_channel=192, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn0_t=dict( + type='NormConnector', in_channels=192, norm_cfg=norm_cfg), + fpn1_s=dict( + type='ConvModuleConnector', + in_channel=128, + out_channel=192, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn1_t=dict( + type='NormConnector', in_channels=192, norm_cfg=norm_cfg), + fpn2_s=dict( + type='ConvModuleConnector', + in_channel=128, + out_channel=192, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn2_t=dict( + type='NormConnector', in_channels=192, norm_cfg=norm_cfg)), + distill_losses=dict( + loss_fpn0=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn1=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn2=dict(type='ChannelWiseDivergence', loss_weight=1)), + # `loss_forward_mappings` are mappings between distill loss forward + # arguments and records. + loss_forward_mappings=dict( + loss_fpn0=dict( + preds_S=dict( + from_student=True, recorder='fpn0', connector='fpn0_s'), + preds_T=dict( + from_student=False, recorder='fpn0', connector='fpn0_t')), + loss_fpn1=dict( + preds_S=dict( + from_student=True, recorder='fpn1', connector='fpn1_s'), + preds_T=dict( + from_student=False, recorder='fpn1', connector='fpn1_t')), + loss_fpn2=dict( + preds_S=dict( + from_student=True, recorder='fpn2', connector='fpn2_s'), + preds_T=dict( + from_student=False, recorder='fpn2', + connector='fpn2_t'))))) + +find_unused_parameters = True + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=_base_.max_epochs - _base_.num_epochs_stage2, + switch_pipeline=_base_.train_pipeline_stage2), + # stop distillation after the 280th epoch + dict(type='mmrazor.StopDistillHook', stop_epoch=280) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_tiny_rtmdet_s_neck_300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_tiny_rtmdet_s_neck_300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..50c23580bf6b7c1a120267a65bc7cc334513c475 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/distillation/kd_tiny_rtmdet_s_neck_300e_coco.py @@ -0,0 +1,99 @@ +_base_ = '../rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py' + +teacher_ckpt = 'https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco/rtmdet_s_syncbn_fast_8xb32-300e_coco_20221230_182329-0a8c901a.pth' # noqa: E501 + +norm_cfg = dict(type='BN', affine=False, track_running_stats=False) + +model = dict( + _delete_=True, + _scope_='mmrazor', + type='FpnTeacherDistill', + architecture=dict( + cfg_path='mmyolo::rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py'), + teacher=dict( + cfg_path='mmyolo::rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py'), + teacher_ckpt=teacher_ckpt, + distiller=dict( + type='ConfigurableDistiller', + # `recorders` are used to record various intermediate results during + # the model forward. + student_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv'), + ), + teacher_recorders=dict( + fpn0=dict(type='ModuleOutputs', source='neck.out_layers.0.conv'), + fpn1=dict(type='ModuleOutputs', source='neck.out_layers.1.conv'), + fpn2=dict(type='ModuleOutputs', source='neck.out_layers.2.conv')), + # `connectors` are adaptive layers which usually map teacher's and + # students features to the same dimension. + connectors=dict( + fpn0_s=dict( + type='ConvModuleConnector', + in_channel=96, + out_channel=128, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn0_t=dict( + type='NormConnector', in_channels=128, norm_cfg=norm_cfg), + fpn1_s=dict( + type='ConvModuleConnector', + in_channel=96, + out_channel=128, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn1_t=dict( + type='NormConnector', in_channels=128, norm_cfg=norm_cfg), + fpn2_s=dict( + type='ConvModuleConnector', + in_channel=96, + out_channel=128, + bias=False, + norm_cfg=norm_cfg, + act_cfg=None), + fpn2_t=dict( + type='NormConnector', in_channels=128, norm_cfg=norm_cfg)), + distill_losses=dict( + loss_fpn0=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn1=dict(type='ChannelWiseDivergence', loss_weight=1), + loss_fpn2=dict(type='ChannelWiseDivergence', loss_weight=1)), + # `loss_forward_mappings` are mappings between distill loss forward + # arguments and records. + loss_forward_mappings=dict( + loss_fpn0=dict( + preds_S=dict( + from_student=True, recorder='fpn0', connector='fpn0_s'), + preds_T=dict( + from_student=False, recorder='fpn0', connector='fpn0_t')), + loss_fpn1=dict( + preds_S=dict( + from_student=True, recorder='fpn1', connector='fpn1_s'), + preds_T=dict( + from_student=False, recorder='fpn1', connector='fpn1_t')), + loss_fpn2=dict( + preds_S=dict( + from_student=True, recorder='fpn2', connector='fpn2_s'), + preds_T=dict( + from_student=False, recorder='fpn2', + connector='fpn2_t'))))) + +find_unused_parameters = True + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=_base_.max_epochs - _base_.num_epochs_stage2, + switch_pipeline=_base_.train_pipeline_stage2), + # stop distillation after the 280th epoch + dict(type='mmrazor.StopDistillHook', stop_epoch=280) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..704a44ba83c90d1c639d4bcbabf88b72fa867553 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/metafile.yml @@ -0,0 +1,215 @@ +Collections: + - Name: RTMDet + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Flat Cosine Annealing + Training Resources: 8x A100 GPUs + Architecture: + - CSPNeXt + - CSPNeXtPAFPN + README: configs/rtmdet/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.1.1 + - Name: Rotated_RTMDet + Metadata: + Training Data: DOTAv1.0 + Training Techniques: + - AdamW + - Flat Cosine Annealing + Training Resources: 1x A100 GPUs + Architecture: + - CSPNeXt + - CSPNeXtPAFPN + README: configs/rtmdet/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.1.1 + +Models: + - Name: rtmdet_tiny_syncbn_fast_8xb32-300e_coco + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 11.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco/rtmdet_tiny_syncbn_fast_8xb32-300e_coco_20230102_140117-dbb1dc83.pth + + - Name: kd_tiny_rtmdet_s_neck_300e_coco + In Collection: RTMDet + Config: configs/rtmdet/distillation/kd_tiny_rtmdet_s_neck_300e_coco.py + Metadata: + Training Memory (GB): 11.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.8 + Weights: https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_tiny_rtmdet_s_neck_300e_coco/kd_tiny_rtmdet_s_neck_300e_coco_20230213_104240-e1e4197c.pth + + - Name: rtmdet_s_syncbn_fast_8xb32-300e_coco + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 15.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.6 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco/rtmdet_s_syncbn_fast_8xb32-300e_coco_20221230_182329-0a8c901a.pth + + - Name: kd_s_rtmdet_m_neck_300e_coco + In Collection: RTMDet + Config: configs/rtmdet/distillation/kd_s_rtmdet_m_neck_300e_coco.py + Metadata: + Training Memory (GB): 16.3 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.7 + Weights: https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_s_rtmdet_m_neck_300e_coco/kd_s_rtmdet_m_neck_300e_coco_20230220_140647-446ff003.pth + + - Name: rtmdet_m_syncbn_fast_8xb32-300e_coco + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 27.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.3 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco/rtmdet_m_syncbn_fast_8xb32-300e_coco_20230102_135952-40af4fe8.pth + + - Name: kd_m_rtmdet_l_neck_300e_coco + In Collection: RTMDet + Config: configs/rtmdet/distillation/kd_m_rtmdet_l_neck_300e_coco.py + Metadata: + Training Memory (GB): 29.0 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.2 + Weights: https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_m_rtmdet_l_neck_300e_coco/kd_m_rtmdet_l_neck_300e_coco_20230220_141313-b806f503.pth + + - Name: rtmdet_l_syncbn_fast_8xb32-300e_coco + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 43.2 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.4 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco/rtmdet_l_syncbn_fast_8xb32-300e_coco_20230102_135928-ee3abdc4.pth + + - Name: kd_l_rtmdet_x_neck_300e_coco + In Collection: RTMDet + Config: configs/rtmdet/distillation/kd_l_rtmdet_x_neck_300e_coco.py + Metadata: + Training Memory (GB): 45.2 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.3 + Weights: https://download.openmmlab.com/mmrazor/v1/rtmdet_distillation/kd_l_rtmdet_x_neck_300e_coco/kd_l_rtmdet_x_neck_300e_coco_20230220_141912-c9979722.pth + + - Name: rtmdet_x_syncbn_fast_8xb32-300e_coco + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 63.4 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.8 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco/rtmdet_x_syncbn_fast_8xb32-300e_coco_20221231_100345-b85cd476.pth + + - Name: rtmdet-r_tiny_fast_1xb8-36e_dota + In Collection: Rotated_RTMDet + Config: configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota.py + Metadata: + Training Memory (GB): 12.7 + Epochs: 36 + Results: + - Task: Oriented Object Detection + Dataset: DOTAv1.0 + Metrics: + mAP: 75.07 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota/rtmdet-r_tiny_fast_1xb8-36e_dota_20230228_162210-e8ccfb1c.pth + + - Name: rtmdet-r_s_fast_1xb8-36e_dota + In Collection: Rotated_RTMDet + Config: configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota.py + Metadata: + Training Memory (GB): 16.6 + Epochs: 36 + Results: + - Task: Oriented Object Detection + Dataset: DOTAv1.0 + Metrics: + mAP: 77.33 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota/rtmdet-r_s_fast_1xb8-36e_dota_20230224_110307-3946a5aa.pth + + - Name: rtmdet-r_m_syncbn_fast_2xb4-36e_dota + In Collection: Rotated_RTMDet + Config: configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota.py + Metadata: + Training Resources: 2x A100 GPUs + Training Memory (GB): 10.9 + Epochs: 36 + Results: + - Task: Oriented Object Detection + Dataset: DOTAv1.0 + Metrics: + mAP: 78.43 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota/rtmdet-r_m_syncbn_fast_2xb4-36e_dota_20230224_124237-29ae1619.pth + + - Name: rtmdet-r_l_syncbn_fast_2xb4-36e_dota + In Collection: Rotated_RTMDet + Config: configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py + Metadata: + Training Resources: 2x A100 GPUs + Training Memory (GB): 16.1 + Epochs: 36 + Results: + - Task: Oriented Object Detection + Dataset: DOTAv1.0 + Metrics: + mAP: 78.66 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota/rtmdet-r_l_syncbn_fast_2xb4-36e_dota_20230224_124544-38bc5f08.pth + + - Name: rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota + In Collection: Rotated_RTMDet + Config: configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota.py + Metadata: + Training Resources: 2x A100 GPUs + Training Memory (GB): 19.6 + Epochs: 100 + Results: + - Task: Oriented Object Detection + Dataset: DOTAv1.0 + Metrics: + mAP: 80.14 + Weights: https://download.openmmlab.com/mmyolo/v0/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota_20230224_124735-ed4ea966.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py new file mode 100644 index 0000000000000000000000000000000000000000..ef29a1d051b84d8c546edb3cabb958ec586e1261 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py @@ -0,0 +1,30 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py' + +# ========================modified parameters====================== +data_root = 'data/split_ms_dota/' +# Path of test images folder +test_data_prefix = 'test/images/' +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +train_dataloader = dict(dataset=dict(data_root=data_root)) + +val_dataloader = dict(dataset=dict(data_root=data_root)) + +# Inference on val dataset +test_dataloader = val_dataloader + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py new file mode 100644 index 0000000000000000000000000000000000000000..cbb2ae77a370a73e463068e11291afb4a59cda02 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py @@ -0,0 +1,331 @@ +_base_ = '../../_base_/default_runtime.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-l_8xb256-rsb-a1-600e_in1k-6a760974.pth' # noqa + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/split_ss_dota/' +# Path of train annotation folder +train_ann_file = 'trainval/annfiles/' +train_data_prefix = 'trainval/images/' # Prefix of train image path +# Path of val annotation folder +val_ann_file = 'trainval/annfiles/' +val_data_prefix = 'trainval/images/' # Prefix of val image path +# Path of test images folder +test_data_prefix = 'test/images/' + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +num_classes = 15 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 4 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0. +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 1xb8=8 bs +base_lr = 0.00025 # 0.004 / 16 +max_epochs = 36 # Maximum training epochs + +model_test_cfg = dict( + # The config of multi-label for multi-class prediction. + multi_label=True, + # Decode rbox with angle, For RTMDet-R, Defaults to True. + # When set to True, use rbox coder such as DistanceAnglePointCoder + # When set to False, use hbox coder such as DistancePointBBoxCoder + # different setting lead to different AP. + decode_with_angle=True, + # The number of boxes before NMS + nms_pre=30000, + score_thr=0.05, # Threshold to filter out boxes. + nms=dict(type='nms_rotated', iou_threshold=0.1), # NMS type and threshold + max_per_img=2000) # Max number of detections of each image + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (1024, 1024) # width, height +# ratio for random rotate +random_rotate_ratio = 0.5 +# label ids for rect objs +rotate_rect_obj_labels = [9, 11] +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5DOTADataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 8 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 8 + +# Config of batch shapes. Only on val. Not use in RTMDet-R +batch_shapes_cfg = None + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 1.0 +# The scaling factor that controls the width of the network structure +widen_factor = 1.0 +# Strides of multi-scale prior box +strides = [8, 16, 32] +# The angle definition for model +angle_version = 'le90' # le90, le135, oc are available options + +norm_cfg = dict(type='BN') # Normalization config + +# -----train val related----- +lr_start_factor = 1.0e-5 +dsl_topk = 13 # Number of bbox selected in each level +loss_cls_weight = 1.0 +loss_bbox_weight = 2.0 +qfl_beta = 2.0 # beta of QualityFocalLoss +weight_decay = 0.05 + +# Save model checkpoint and validation intervals +save_checkpoint_intervals = 1 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 +# single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + type='CSPNeXt', + arch='P5', + expand_ratio=0.5, + deepen_factor=deepen_factor, + widen_factor=widen_factor, + channel_attention=True, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint)), + neck=dict( + type='CSPNeXtPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=256, + num_csp_blocks=3, + expand_ratio=0.5, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='RTMDetRotatedHead', + head_module=dict( + type='RTMDetRotatedSepBNHeadModule', + num_classes=num_classes, + widen_factor=widen_factor, + in_channels=256, + stacked_convs=2, + feat_channels=256, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + share_conv=True, + pred_kernel_size=1, + featmap_strides=strides), + prior_generator=dict( + type='mmdet.MlvlPointGenerator', offset=0, strides=strides), + bbox_coder=dict( + type='DistanceAnglePointCoder', angle_version=angle_version), + loss_cls=dict( + type='mmdet.QualityFocalLoss', + use_sigmoid=True, + beta=qfl_beta, + loss_weight=loss_cls_weight), + loss_bbox=dict( + type='mmrotate.RotatedIoULoss', + mode='linear', + loss_weight=loss_bbox_weight), + angle_version=angle_version, + # Used for angle encode and decode, similar to bbox coder + angle_coder=dict(type='mmrotate.PseudoAngleCoder'), + # If true, it will apply loss_bbox on horizontal box, and angle_loss + # needs to be specified. In this case the loss_bbox should use + # horizontal box loss e.g. IoULoss. Arg details can be seen in + # `docs/zh_cn/tutorials/rotated_detection.md` + use_hbbox_loss=False, + loss_angle=None), + train_cfg=dict( + assigner=dict( + type='BatchDynamicSoftLabelAssigner', + num_classes=num_classes, + topk=dsl_topk, + iou_calculator=dict(type='mmrotate.RBboxOverlaps2D'), + # RBboxOverlaps2D doesn't support batch input, use loop instead. + batch_iou=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=model_test_cfg, +) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True, box_type='qbox'), + dict( + type='mmrotate.ConvertBoxType', + box_type_mapping=dict(gt_bboxes='rbox')), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=True), + dict( + type='mmdet.RandomFlip', + prob=0.75, + direction=['horizontal', 'vertical', 'diagonal']), + dict( + type='mmrotate.RandomRotate', + prob=random_rotate_ratio, + angle_range=180, + rotate_type='mmrotate.Rotate', + rect_obj_labels=rotate_rect_obj_labels), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict(type='RegularizeRotatedBox', angle_version=angle_version), + dict(type='mmdet.PackDetInputs') +] + +val_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=True), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='LoadAnnotations', + with_bbox=True, + box_type='qbox', + _scope_='mmdet'), + dict( + type='mmrotate.ConvertBoxType', + box_type_mapping=dict(gt_bboxes='rbox')), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=True), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + collate_fn=dict(type='yolov5_collate'), + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img_path=train_data_prefix), + filter_cfg=dict(filter_empty_gt=True), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=val_ann_file, + data_prefix=dict(img_path=val_data_prefix), + test_mode=True, + batch_shapes_cfg=batch_shapes_cfg, + pipeline=val_pipeline)) + +val_evaluator = dict(type='mmrotate.DOTAMetric', metric='mAP') + +# Inference on val dataset +test_dataloader = val_dataloader +test_evaluator = val_evaluator + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# batch_size=val_batch_size_per_gpu, +# num_workers=val_num_workers, +# persistent_workers=True, +# drop_last=False, +# sampler=dict(type='DefaultSampler', shuffle=False), +# dataset=dict( +# type=dataset_type, +# data_root=data_root, +# data_prefix=dict(img_path=test_data_prefix), +# test_mode=True, +# batch_shapes_cfg=batch_shapes_cfg, +# pipeline=test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=base_lr, weight_decay=weight_decay), + paramwise_cfg=dict( + norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=lr_start_factor, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +# hooks +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=save_checkpoint_intervals, + max_keep_ckpts=max_keep_ckpts, # only keep latest 3 checkpoints + save_best='auto')) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_checkpoint_intervals) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +visualizer = dict(type='mmrotate.RotLocalVisualizer') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota.py new file mode 100644 index 0000000000000000000000000000000000000000..dcafa55db97ffd543af3bc382d15de361cadbd75 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_2xb4-aug-100e_dota.py @@ -0,0 +1,168 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py' + +# This config use longer schedule with Mixup, Mosaic and Random Rotate. + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-l_8xb256-rsb-a1-600e_in1k-6a760974.pth' # noqa + +# ========================modified parameters====================== + +# Base learning rate for optim_wrapper. Corresponding to 1xb8=8 bs +base_lr = 0.00025 # 0.004 / 16 +lr_start_factor = 1.0e-5 +max_epochs = 100 # Maximum training epochs +# Change train_pipeline for final 10 epochs (stage 2) +num_epochs_stage2 = 10 + +img_scale = (1024, 1024) # width, height +# ratio range for random resize +random_resize_ratio_range = (0.1, 2.0) +# Cached images number in mosaic +mosaic_max_cached_images = 40 +# Number of cached images in mixup +mixup_max_cached_images = 20 +# ratio for random rotate +random_rotate_ratio = 0.5 +# label ids for rect objs +rotate_rect_obj_labels = [9, 11] + +# Save model checkpoint and validation intervals +save_checkpoint_intervals = 1 +# validation intervals in stage 2 +val_interval_stage2 = 1 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True, box_type='qbox'), + dict( + type='mmrotate.ConvertBoxType', + box_type_mapping=dict(gt_bboxes='rbox')), + dict( + type='Mosaic', + img_scale=img_scale, + use_cached=True, + max_cached_images=mosaic_max_cached_images, + pad_val=114.0), + dict( + type='mmdet.RandomResize', + # img_scale is (width, height) + scale=(img_scale[0] * 2, img_scale[1] * 2), + ratio_range=random_resize_ratio_range, + resize_type='mmdet.Resize', + keep_ratio=True), + dict( + type='mmrotate.RandomRotate', + prob=random_rotate_ratio, + angle_range=180, + rotate_type='mmrotate.Rotate', + rect_obj_labels=rotate_rect_obj_labels), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict( + type='mmdet.RandomFlip', + prob=0.75, + direction=['horizontal', 'vertical', 'diagonal']), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='YOLOv5MixUp', + use_cached=True, + max_cached_images=mixup_max_cached_images), + dict(type='mmdet.PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True, box_type='qbox'), + dict( + type='mmrotate.ConvertBoxType', + box_type_mapping=dict(gt_bboxes='rbox')), + dict( + type='mmdet.RandomResize', + scale=img_scale, + ratio_range=random_resize_ratio_range, + resize_type='mmdet.Resize', + keep_ratio=True), + dict( + type='mmrotate.RandomRotate', + prob=random_rotate_ratio, + angle_range=180, + rotate_type='mmrotate.Rotate', + rect_obj_labels=rotate_rect_obj_labels), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict( + type='mmdet.RandomFlip', + prob=0.75, + direction=['horizontal', 'vertical', 'diagonal']), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict(type='mmdet.PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=lr_start_factor, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +# hooks +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=save_checkpoint_intervals, + max_keep_ckpts=max_keep_ckpts, # only keep latest 3 checkpoints + save_best='auto')) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - num_epochs_stage2, + switch_pipeline=train_pipeline_stage2) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_checkpoint_intervals, + dynamic_intervals=[(max_epochs - num_epochs_stage2, val_interval_stage2)]) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_coco-pretrain_2xb4-36e_dota-ms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_coco-pretrain_2xb4-36e_dota-ms.py new file mode 100644 index 0000000000000000000000000000000000000000..1a9f50cdded21c36f9b76b49e291b60e0a2dff07 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_l_syncbn_fast_coco-pretrain_2xb4-36e_dota-ms.py @@ -0,0 +1,20 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py' + +load_from = 'https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco/rtmdet_l_syncbn_fast_8xb32-300e_coco_20230102_135928-ee3abdc4.pth' # noqa + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota-ms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota-ms.py new file mode 100644 index 0000000000000000000000000000000000000000..4be8605f6de383c4e39edae6cfdc19f5ea005353 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota-ms.py @@ -0,0 +1,33 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-m_8xb256-rsb-a1-600e_in1k-ecb3bbd9.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota.py new file mode 100644 index 0000000000000000000000000000000000000000..8df61cffd6e165e36965b2622735abb93fbe8d83 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_m_syncbn_fast_2xb4-36e_dota.py @@ -0,0 +1,33 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-m_8xb256-rsb-a1-600e_in1k-ecb3bbd9.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota-ms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota-ms.py new file mode 100644 index 0000000000000000000000000000000000000000..2b7b0b6ffee9cdf2720696ce6fe51b87927ada6e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota-ms.py @@ -0,0 +1,38 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.5 + +# Batch size of a single GPU during training +train_batch_size_per_gpu = 8 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota.py new file mode 100644 index 0000000000000000000000000000000000000000..d200dd76491dafb306900de23a25359224205d13 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_s_fast_1xb8-36e_dota.py @@ -0,0 +1,38 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.5 + +# Batch size of a single GPU during training +train_batch_size_per_gpu = 8 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota-ms.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota-ms.py new file mode 100644 index 0000000000000000000000000000000000000000..56bf038b6500bb0640160e680ddbb5e4c34fd3f8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota-ms.py @@ -0,0 +1,38 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota-ms.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.167 +widen_factor = 0.375 + +# Batch size of a single GPU during training +train_batch_size_per_gpu = 8 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota.py new file mode 100644 index 0000000000000000000000000000000000000000..739a2de8020ad6879a8401255395df2e807f66c4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rotated/rtmdet-r_tiny_fast_1xb8-36e_dota.py @@ -0,0 +1,38 @@ +_base_ = './rtmdet-r_l_syncbn_fast_2xb4-36e_dota.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.167 +widen_factor = 0.375 + +# Batch size of a single GPU during training +train_batch_size_per_gpu = 8 + +# Submission dir for result submit +submission_dir = './work_dirs/{{fileBasenameNoExtension}}/submission' + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) + +# Inference on test dataset and format the output results +# for submission. Note: the test set has no annotation. +# test_dataloader = dict( +# dataset=dict( +# data_root=_base_.data_root, +# ann_file='', # test set has no annotation +# data_prefix=dict(img_path=_base_.test_data_prefix), +# pipeline=_base_.test_pipeline)) +# test_evaluator = dict( +# type='mmrotate.DOTAMetric', +# format_only=True, +# merge_patches=True, +# outfile_prefix=submission_dir) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet-ins_s_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet-ins_s_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..279a7990bc4a58a5c10bfc3dd29e570c7e3a14cc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet-ins_s_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,31 @@ +_base_ = './rtmdet_s_syncbn_fast_8xb32-300e_coco.py' + +widen_factor = 0.5 + +model = dict( + bbox_head=dict( + type='RTMDetInsSepBNHead', + head_module=dict( + type='RTMDetInsSepBNHeadModule', + use_sigmoid_cls=True, + widen_factor=widen_factor), + loss_mask=dict( + type='mmdet.DiceLoss', loss_weight=2.0, eps=5e-6, + reduction='mean')), + test_cfg=dict( + multi_label=True, + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100, + mask_thr_binary=0.5)) + +_base_.test_pipeline[-2] = dict( + type='LoadAnnotations', with_bbox=True, with_mask=True, _scope_='mmdet') + +val_dataloader = dict(dataset=dict(pipeline=_base_.test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict(metric=['bbox', 'segm']) +test_evaluator = val_evaluator diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..c36ac38ce16db6bbd66fe0c2271c34c252a538ab --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_l_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,304 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/coco/' +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 32 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 10 +# persistent_workers must be False if num_workers is 0. +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 8xb16=64 bs +base_lr = 0.004 +max_epochs = 300 # Maximum training epochs +# Change train_pipeline for final 20 epochs (stage 2) +num_epochs_stage2 = 20 + +model_test_cfg = dict( + # The config of multi-label for multi-class prediction. + multi_label=True, + # The number of boxes before NMS + nms_pre=30000, + score_thr=0.001, # Threshold to filter out boxes. + nms=dict(type='nms', iou_threshold=0.65), # NMS type and threshold + max_per_img=300) # Max number of detections of each image + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (640, 640) # width, height +# ratio range for random resize +random_resize_ratio_range = (0.1, 2.0) +# Cached images number in mosaic +mosaic_max_cached_images = 40 +# Number of cached images in mixup +mixup_max_cached_images = 20 +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 32 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 10 + +# Config of batch shapes. Only on val. +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + size_divisor=32, + extra_pad_ratio=0.5) + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 1.0 +# The scaling factor that controls the width of the network structure +widen_factor = 1.0 +# Strides of multi-scale prior box +strides = [8, 16, 32] + +norm_cfg = dict(type='BN') # Normalization config + +# -----train val related----- +lr_start_factor = 1.0e-5 +dsl_topk = 13 # Number of bbox selected in each level +loss_cls_weight = 1.0 +loss_bbox_weight = 2.0 +qfl_beta = 2.0 # beta of QualityFocalLoss +weight_decay = 0.05 + +# Save model checkpoint and validation intervals +save_checkpoint_intervals = 10 +# validation intervals in stage 2 +val_interval_stage2 = 1 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 +# single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + type='CSPNeXt', + arch='P5', + expand_ratio=0.5, + deepen_factor=deepen_factor, + widen_factor=widen_factor, + channel_attention=True, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + type='CSPNeXtPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=256, + num_csp_blocks=3, + expand_ratio=0.5, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='RTMDetHead', + head_module=dict( + type='RTMDetSepBNHeadModule', + num_classes=num_classes, + in_channels=256, + stacked_convs=2, + feat_channels=256, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + share_conv=True, + pred_kernel_size=1, + featmap_strides=strides), + prior_generator=dict( + type='mmdet.MlvlPointGenerator', offset=0, strides=strides), + bbox_coder=dict(type='DistancePointBBoxCoder'), + loss_cls=dict( + type='mmdet.QualityFocalLoss', + use_sigmoid=True, + beta=qfl_beta, + loss_weight=loss_cls_weight), + loss_bbox=dict(type='mmdet.GIoULoss', loss_weight=loss_bbox_weight)), + train_cfg=dict( + assigner=dict( + type='BatchDynamicSoftLabelAssigner', + num_classes=num_classes, + topk=dsl_topk, + iou_calculator=dict(type='mmdet.BboxOverlaps2D')), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=model_test_cfg, +) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Mosaic', + img_scale=img_scale, + use_cached=True, + max_cached_images=mosaic_max_cached_images, + pad_val=114.0), + dict( + type='mmdet.RandomResize', + # img_scale is (width, height) + scale=(img_scale[0] * 2, img_scale[1] * 2), + ratio_range=random_resize_ratio_range, + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='YOLOv5MixUp', + use_cached=True, + max_cached_images=mixup_max_cached_images), + dict(type='mmdet.PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='mmdet.RandomResize', + scale=img_scale, + ratio_range=random_resize_ratio_range, + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict(type='mmdet.PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + collate_fn=dict(type='yolov5_collate'), + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=val_ann_file, + data_prefix=dict(img=val_data_prefix), + test_mode=True, + batch_shapes_cfg=batch_shapes_cfg, + pipeline=test_pipeline)) + +test_dataloader = val_dataloader + +# Reduce evaluation time +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=base_lr, weight_decay=weight_decay), + paramwise_cfg=dict( + norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=lr_start_factor, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +# hooks +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=save_checkpoint_intervals, + max_keep_ckpts=max_keep_ckpts # only keep latest 3 checkpoints + )) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - num_epochs_stage2, + switch_pipeline=train_pipeline_stage2) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_checkpoint_intervals, + dynamic_intervals=[(max_epochs - num_epochs_stage2, val_interval_stage2)]) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..52576bf41689f462e46e83e6236de91ead43e97c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_m_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,11 @@ +_base_ = './rtmdet_l_syncbn_fast_8xb32-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8cead7805974a0a9434f41623ab92beb87fadc60 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,92 @@ +_base_ = './rtmdet_l_syncbn_fast_8xb32-300e_coco.py' +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.5 +img_scale = _base_.img_scale + +# ratio range for random resize +random_resize_ratio_range = (0.5, 2.0) +# Number of cached images in mosaic +mosaic_max_cached_images = 40 +# Number of cached images in mixup +mixup_max_cached_images = 20 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + # Since the checkpoint includes CUDA:0 data, + # it must be forced to set map_location. + # Once checkpoint is fixed, it can be removed. + init_cfg=dict( + type='Pretrained', + prefix='backbone.', + checkpoint=checkpoint, + map_location='cpu')), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Mosaic', + img_scale=img_scale, + use_cached=True, + max_cached_images=mosaic_max_cached_images, + pad_val=114.0), + dict( + type='mmdet.RandomResize', + # img_scale is (width, height) + scale=(img_scale[0] * 2, img_scale[1] * 2), + ratio_range=random_resize_ratio_range, # note + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='YOLOv5MixUp', + use_cached=True, + max_cached_images=mixup_max_cached_images), + dict(type='mmdet.PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='mmdet.RandomResize', + scale=img_scale, + ratio_range=random_resize_ratio_range, # note + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict(type='mmdet.PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=_base_.max_epochs - _base_.num_epochs_stage2, + switch_pipeline=train_pipeline_stage2) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_tiny_fast_1xb12-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_tiny_fast_1xb12-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..8d1182c5ef663efdf06801c6cc22991b9545b2ea --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_tiny_fast_1xb12-40e_cat.py @@ -0,0 +1,70 @@ +_base_ = 'rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +num_epochs_stage2 = 5 + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 4 +val_batch_size_per_gpu = 1 +val_num_workers = 2 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco/rtmdet_tiny_syncbn_fast_8xb32-300e_coco_20230102_140117-dbb1dc83.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict(head_module=dict(num_classes=num_classes)), + train_cfg=dict(assigner=dict(num_classes=num_classes))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +param_scheduler = [ + dict( + type='LinearLR', + start_factor=_base_.lr_start_factor, + by_epoch=False, + begin=0, + end=30), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=_base_.base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +_base_.custom_hooks[1].switch_epoch = max_epochs - num_epochs_stage2 + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..257110d22e9f2330e4c5378001eaf72f6bb885d1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_tiny_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,58 @@ +_base_ = './rtmdet_s_syncbn_fast_8xb32-300e_coco.py' +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.167 +widen_factor = 0.375 +img_scale = _base_.img_scale + +# ratio range for random resize +random_resize_ratio_range = (0.5, 2.0) +# Number of cached images in mosaic +mosaic_max_cached_images = 20 +# Number of cached images in mixup +mixup_max_cached_images = 10 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + init_cfg=dict(checkpoint=checkpoint)), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Mosaic', + img_scale=img_scale, + use_cached=True, + max_cached_images=mosaic_max_cached_images, # note + random_pop=False, # note + pad_val=114.0), + dict( + type='mmdet.RandomResize', + # img_scale is (width, height) + scale=(img_scale[0] * 2, img_scale[1] * 2), + ratio_range=random_resize_ratio_range, + resize_type='mmdet.Resize', + keep_ratio=True), + dict(type='mmdet.RandomCrop', crop_size=img_scale), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict(type='mmdet.Pad', size=img_scale, pad_val=dict(img=(114, 114, 114))), + dict( + type='YOLOv5MixUp', + use_cached=True, + random_pop=False, + max_cached_images=mixup_max_cached_images, + prob=0.5), + dict(type='mmdet.PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..7fc9001f99ef3d468994c8201d43f08500bdeef9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/rtmdet/rtmdet_x_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,11 @@ +_base_ = './rtmdet_l_syncbn_fast_8xb32-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 1.33 +widen_factor = 1.25 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bd33e83f430b9309e4c0e95902a61db0dd7ae002 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/README.md @@ -0,0 +1,146 @@ +# YOLOv5 + + + +## Abstract + +YOLOv5 is a family of object detection architectures and models pretrained on the COCO dataset, and represents Ultralytics open-source research into future vision AI methods, incorporating lessons learned and best practices evolved over thousands of hours of research and development. + +
+ +YOLOv5-l-P5 model structure +
+ +
+ +YOLOv5-l-P6 model structure +
+ +## Results and models + +### COCO + +| Backbone | Arch | size | Mask Refine | SyncBN | AMP | Mem (GB) | box AP | TTA box AP | Config | Download | +| :-------: | :--: | :--: | :---------: | :----: | :-: | :------: | :---------: | :--------: | :-----------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOv5-n | P5 | 640 | No | Yes | Yes | 1.5 | 28.0 | 30.7 | [config](./yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739-b804c1ad.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739.log.json) | +| YOLOv5-n | P5 | 640 | Yes | Yes | Yes | 1.5 | 28.0 | | [config](./mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_152706-712fb1b2.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_152706.log.json) | +| YOLOv5u-n | P5 | 640 | Yes | Yes | Yes | | | | [config](./yolov5/yolov5u/yolov5_n_mask-refine_syncbn_fast_8xb16-300e_coco.py) | [model](<>) \| [log](<>) | +| YOLOv5-s | P5 | 640 | No | Yes | Yes | 2.7 | 37.7 | 40.2 | [config](./yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json) | +| YOLOv5-s | P5 | 640 | Yes | Yes | Yes | 2.7 | 38.0 (+0.3) | | [config](./mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230304_033134-8e0cd271.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230304_033134.log.json) | +| YOLOv5u-s | P5 | 640 | Yes | Yes | Yes | | | | [config](./yolov5/yolov5u/yolov5_s_mask-refine_syncbn_fast_8xb16-300e_coco.py) | [model](<>) \| [log](<>) | +| YOLOv5-m | P5 | 640 | No | Yes | Yes | 5.0 | 45.3 | 46.9 | [config](./yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944.log.json) | +| YOLOv5-m | P5 | 640 | Yes | Yes | Yes | 5.0 | 45.3 | | [config](./mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_153946-44e96155.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_153946.log.json) | +| YOLOv5u-m | P5 | 640 | Yes | Yes | Yes | | | | [config](./yolov5/yolov5u/yolov5_m_mask-refine_syncbn_fast_8xb16-300e_coco.py) | [model](<>) \| [log](<>) | +| YOLOv5-l | P5 | 640 | No | Yes | Yes | 8.1 | 48.8 | 49.9 | [config](./yolov5_l-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco/yolov5_l-v61_syncbn_fast_8xb16-300e_coco_20220917_031007-096ef0eb.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco/yolov5_l-v61_syncbn_fast_8xb16-300e_coco_20220917_031007.log.json) | +| YOLOv5-l | P5 | 640 | Yes | Yes | Yes | 8.1 | 49.3 (+0.5) | | [config](./mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_154301-2c1d912a.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_154301.log.json) | +| YOLOv5u-l | P5 | 640 | Yes | Yes | Yes | | | | [config](./yolov5/yolov5u/yolov5_l_mask-refine_syncbn_fast_8xb16-300e_coco.py) | [model](<>) \| [log](<>) | +| YOLOv5-x | P5 | 640 | No | Yes | Yes | 12.2 | 50.2 | | [config](./yolov5_x-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco/yolov5_x-v61_syncbn_fast_8xb16-300e_coco_20230305_152943-00776a4b.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco/yolov5_x-v61_syncbn_fast_8xb16-300e_coco_20230305_152943.log.json) | +| YOLOv5-x | P5 | 640 | Yes | Yes | Yes | 12.2 | 50.9 (+0.7) | | [config](./mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_154321-07edeb62.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_154321.log.json) | +| YOLOv5u-x | P5 | 640 | Yes | Yes | Yes | | | | [config](./yolov5/yolov5u/yolov5_x_mask-refine_syncbn_fast_8xb16-300e_coco.py) | [model](<>) \| [log](<>) | +| YOLOv5-n | P6 | 1280 | No | Yes | Yes | 5.8 | 35.9 | | [config](./yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_224705-d493c5f3.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_224705.log.json) | +| YOLOv5-s | P6 | 1280 | No | Yes | Yes | 10.5 | 44.4 | | [config](./yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_215044-58865c19.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_215044.log.json) | +| YOLOv5-m | P6 | 1280 | No | Yes | Yes | 19.1 | 51.3 | | [config](./yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_230453-49564d58.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_230453.log.json) | +| YOLOv5-l | P6 | 1280 | No | Yes | Yes | 30.5 | 53.7 | | [config](./yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_234308-7a2ba6bf.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_234308.log.json) | + +**Note**: + +1. `fast` means that `YOLOv5DetDataPreprocessor` and `yolov5_collate` are used for data preprocessing, which is faster for training, but less flexible for multitasking. Recommended to use fast version config if you only care about object detection. +2. `detect` means that the network input is fixed to `640x640` and the post-processing thresholds is modified. +3. `SyncBN` means use SyncBN, `AMP` indicates training with mixed precision. +4. We use 8x A100 for training, and the single-GPU batch size is 16. This is different from the official code. +5. The performance is unstable and may fluctuate by about 0.4 mAP and the highest performance weight in `COCO` training in `YOLOv5` may not be the last epoch. +6. `TTA` means that Test Time Augmentation. It's perform 3 multi-scaling transformations on the image, followed by 2 flipping transformations (flipping and not flipping). You only need to specify `--tta` when testing to enable. see [TTA](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/common_usage/tta.md) for details. +7. The performance of `Mask Refine` training is for the weight performance officially released by YOLOv5. `Mask Refine` means refining bbox by mask while loading annotations and transforming after `YOLOv5RandomAffine`, `Copy Paste` means using `YOLOv5CopyPaste`. +8. `YOLOv5u` models use the same loss functions and split Detect head as `YOLOv8` models for improved performance, but only requires 300 epochs. + +### COCO Instance segmentation + +| Backbone | Arch | size | SyncBN | AMP | Mem (GB) | Box AP | Mask AP | Config | Download | +| :-------------------: | :--: | :--: | :----: | :-: | :------: | :----: | :-----: | :--------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOv5-n | P5 | 640 | Yes | Yes | 3.3 | 27.9 | 23.7 | [config](./ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance_20230424_104807-84cc9240.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance_20230424_104807.log.json) | +| YOLOv5-s | P5 | 640 | Yes | Yes | 4.8 | 38.1 | 32.0 | [config](./ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance_20230426_012542-3e570436.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance_20230426_012542.log.json) | +| YOLOv5-s(non-overlap) | P5 | 640 | Yes | Yes | 4.8 | 38.0 | 32.1 | [config](./ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance_20230424_104642-6780d34e.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance_20230424_104642.log.json) | +| YOLOv5-m | P5 | 640 | Yes | Yes | 7.3 | 45.1 | 37.3 | [config](./ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance_20230424_111529-ef5ba1a9.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance_20230424_111529.log.json) | +| YOLOv5-l | P5 | 640 | Yes | Yes | 10.7 | 48.8 | 39.9 | [config](./ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance_20230508_104049-daa09f70.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance_20230508_104049.log.json) | +| YOLOv5-x | P5 | 640 | Yes | Yes | 15.0 | 50.6 | 41.4 | [config](./ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance_20230508_103925-a260c798.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance_20230508_103925.log.json) | + +**Note**: + +1. `Non-overlap` refers to the instance-level masks being stored in the format (num_instances, h, w) instead of (h, w). Storing masks in overlap format consumes less memory and GPU memory. +2. For the M model, the `affine_scale` parameter should be 0.9, but due to some reason, we set it to 0.5 and found that the mAP did not change. Therefore, the released M model has an `affine_scale` parameter of 0.5, which is inconsistent with the value of 0.9 in the configuration. + +### VOC + +| Backbone | size | Batchsize | AMP | Mem (GB) | box AP(COCO metric) | Config | Download | +| :------: | :--: | :-------: | :-: | :------: | :-----------------: | :-------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOv5-n | 512 | 64 | Yes | 3.5 | 51.2 | [config](./yolov5/voc/yolov5_n-v61_fast_1xb64-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_fast_1xb64-50e_voc/yolov5_n-v61_fast_1xb64-50e_voc_20221017_234254-f1493430.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_fast_1xb64-50e_voc/yolov5_n-v61_fast_1xb64-50e_voc_20221017_234254.log.json) | +| YOLOv5-s | 512 | 64 | Yes | 6.5 | 62.7 | [config](./yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_fast_1xb64-50e_voc/yolov5_s-v61_fast_1xb64-50e_voc_20221017_234156-0009b33e.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_fast_1xb64-50e_voc/yolov5_s-v61_fast_1xb64-50e_voc_20221017_234156.log.json) | +| YOLOv5-m | 512 | 64 | Yes | 12.0 | 70.1 | [config](./yolov5/voc/yolov5_m-v61_fast_1xb64-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_fast_1xb64-50e_voc/yolov5_m-v61_fast_1xb64-50e_voc_20221017_114138-815c143a.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_fast_1xb64-50e_voc/yolov5_m-v61_fast_1xb64-50e_voc_20221017_114138.log.json) | +| YOLOv5-l | 512 | 32 | Yes | 10.0 | 73.1 | [config](./yolov5/voc/yolov5_l-v61_fast_1xb32-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_fast_1xb32-50e_voc/yolov5_l-v61_fast_1xb32-50e_voc_20221017_045500-edc7e0d8.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_fast_1xb32-50e_voc/yolov5_l-v61_fast_1xb32-50e_voc_20221017_045500.log.json) | + +**Note**: + +1. Training on VOC dataset need pretrained model which trained on COCO. +2. The performance is unstable and may fluctuate by about 0.4 mAP. +3. Official YOLOv5 use COCO metric, while training VOC dataset. +4. We converted the VOC test dataset to COCO format offline, while reproducing mAP result as shown above. We will support to use COCO metric while training VOC dataset in later version. +5. Hyperparameter reference from `https://wandb.ai/glenn-jocher/YOLOv5_VOC_official`. + +### CrowdHuman + +Since the `iscrowd` annotation of the COCO dataset is not equivalent to `ignore`, we use the CrowdHuman dataset to verify that the YOLOv5 ignore logic is correct. + +| Backbone | size | SyncBN | AMP | Mem (GB) | ignore_iof_thr | box AP50(CrowDHuman Metric) | MR | JI | Config | Download | +| :------: | :--: | :----: | :-: | :------: | :------------: | :-------------------------: | :--: | :---: | :------------------------------------------------------------------------: | :------: | +| YOLOv5-s | 640 | Yes | Yes | 2.6 | -1 | 85.79 | 48.7 | 75.33 | [config](./yolov5/crowdhuman/yolov5_s-v61_fast_8xb16-300e_crowdhuman.py) | | +| YOLOv5-s | 640 | Yes | Yes | 2.6 | 0.5 | 86.17 | 48.8 | 75.87 | [config](./yolov5/crowdhuman/yolov5_s-v61_8xb16-300e_ignore_crowdhuman.py) | | + +**Note**: + +1. `ignore_iof_thr` is -1 indicating that the ignore tag is not considered. We adjusted with `ignore_iof_thr` thresholds of 0.5, 0.8, 0.9, and the results show that 0.5 has the best performance. +2. The above table shows the performance of the model with the best performance on the validation set. The best performing models are around 160+ epoch which means that there is no need to train so many epochs. +3. This is a very simple implementation that simply replaces COCO's anchor with the `tools/analysis_tools/optimize_anchors.py` script. We'll adjust other parameters later to improve performance. + +## Citation + +```latex +@software{glenn_jocher_2022_7002879, + author = {Glenn Jocher and + Ayush Chaurasia and + Alex Stoken and + Jirka Borovec and + NanoCode012 and + Yonghye Kwon and + TaoXie and + Kalen Michael and + Jiacong Fang and + imyhxy and + Lorna and + Colin Wong and + 曾逸夫(Zeng Yifu) and + Abhiram V and + Diego Montes and + Zhiqiang Wang and + Cristi Fati and + Jebastin Nadar and + Laughing and + UnglvKitDe and + tkianai and + yxNONG and + Piotr Skalski and + Adam Hogan and + Max Strobel and + Mrinal Jain and + Lorenzo Mammana and + xylieong}, + title = {{ultralytics/yolov5: v6.2 - YOLOv5 Classification + Models, Apple M1, Reproducibility, ClearML and + Deci.ai integrations}}, + month = aug, + year = 2022, + publisher = {Zenodo}, + version = {v6.2}, + doi = {10.5281/zenodo.7002879}, + url = {https://doi.org/10.5281/zenodo.7002879} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/crowdhuman/yolov5_s-v61_8xb16-300e_ignore_crowdhuman.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/crowdhuman/yolov5_s-v61_8xb16-300e_ignore_crowdhuman.py new file mode 100644 index 0000000000000000000000000000000000000000..85b371929acd68bfd06cc257d20978c3fcc36db7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/crowdhuman/yolov5_s-v61_8xb16-300e_ignore_crowdhuman.py @@ -0,0 +1,63 @@ +_base_ = 'yolov5_s-v61_fast_8xb16-300e_crowdhuman.py' + +model = dict( + data_preprocessor=dict( + _delete_=True, + type='mmdet.DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + bbox_head=dict(ignore_iof_thr=0.5)) + +img_scale = _base_.img_scale + +albu_train_transforms = [ + dict(type='Blur', p=0.01), + dict(type='MedianBlur', p=0.01), + dict(type='ToGray', p=0.01), + dict(type='CLAHE', p=0.01) +] + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + # only change this + dict(type='mmdet.LoadAnnotations', with_bbox=True) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(0.5, 1.5), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + collate_fn=dict(type='pseudo_collate'), + dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/crowdhuman/yolov5_s-v61_fast_8xb16-300e_crowdhuman.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/crowdhuman/yolov5_s-v61_fast_8xb16-300e_crowdhuman.py new file mode 100644 index 0000000000000000000000000000000000000000..a61859fa0f2c0ea8a08ffd7783adc4ccac8540dd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/crowdhuman/yolov5_s-v61_fast_8xb16-300e_crowdhuman.py @@ -0,0 +1,47 @@ +_base_ = '../yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +# Use the model trained on the COCO as the pretrained model +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' # noqa + +# dataset settings +data_root = 'data/CrowdHuman/' +dataset_type = 'YOLOv5CrowdHumanDataset' + +# parameters that often need to be modified +num_classes = 1 + +anchors = [ + [(6, 14), (12, 28), (19, 48)], # P3/8 + [(29, 79), (46, 124), (142, 54)], # P4/16 + [(73, 198), (124, 330), (255, 504)] # P5/32 +] + +model = dict( + bbox_head=dict( + head_module=dict(num_classes=num_classes), + prior_generator=dict(base_sizes=anchors))) + +train_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotation_train.odgt', + data_prefix=dict(img='Images/'))) + +val_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotation_val.odgt', + data_prefix=dict(img='Images/'), + # CrowdHumanMetric does not support out-of-order output images + # for the time being. batch_shapes_cfg does not support. + batch_shapes_cfg=None)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='mmdet.CrowdHumanMetric', + ann_file=data_root + 'annotation_val.odgt', + metric=['AP', 'MR', 'JI']) +test_evaluator = val_evaluator diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..6b27c7647bd233172e11df8e5a736946d70acfe0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance.py @@ -0,0 +1,81 @@ +_base_ = './yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +# This config use refining bbox and `YOLOv5CopyPaste`. +# Refining bbox means refining bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` +# ========================modified parameters====================== +deepen_factor = 1.0 +widen_factor = 1.0 + +mixup_prob = 0.1 +copypaste_prob = 0.1 + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + max_aspect_ratio=_base_.max_aspect_ratio, + use_mask_refine=_base_.use_mask2refine), +] + +# enable mixup +train_pipeline = [ + *pre_transform, + *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + # TODO: support mask transform in albu + # Geometric transformations are not supported in albu now. + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='Polygon2Mask', + downsample_ratio=_base_.downsample_ratio, + mask_overlap=_base_.mask_overlap), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..831e815cb2f982e92c9995bd6e012bcce95950f6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance.py @@ -0,0 +1,89 @@ +_base_ = './yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 +lr_factor = 0.1 +loss_cls_weight = 0.3 +loss_obj_weight = 0.7 + +affine_scale = 0.9 +mixup_prob = 0.1 + +# =======================Unmodified in most cases================== +num_classes = _base_.num_classes +num_det_layers = _base_.num_det_layers +img_scale = _base_.img_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)))) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + max_aspect_ratio=_base_.max_aspect_ratio, + use_mask_refine=_base_.use_mask2refine), +] + +# enable mixup +train_pipeline = [ + *pre_transform, + *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + # TODO: support mask transform in albu + # Geometric transformations are not supported in albu now. + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='Polygon2Mask', + downsample_ratio=_base_.downsample_ratio, + mask_overlap=_base_.mask_overlap), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..e06130bd317dba004a7fa1d5de0750f5b1cd21cf --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance.py @@ -0,0 +1,15 @@ +_base_ = './yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +deepen_factor = 0.33 +widen_factor = 0.25 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..82e2ae6d059df466940fc3df84ce53102ffec081 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py @@ -0,0 +1,42 @@ +_base_ = './yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +data_root = 'data/balloon/' +# Path of train annotation file +train_ann_file = 'train.json' +train_data_prefix = 'train/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'val.json' +val_data_prefix = 'val/' # Prefix of val image path +metainfo = { + 'classes': ('balloon', ), + 'palette': [ + (220, 20, 60), + ] +} +num_classes = 1 + +train_batch_size_per_gpu = 4 +train_num_workers = 2 +log_interval = 1 +##################### +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + data_prefix=dict(img=train_data_prefix), + ann_file=train_ann_file)) +val_dataloader = dict( + dataset=dict( + data_root=data_root, + metainfo=metainfo, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file)) +test_dataloader = val_dataloader +val_evaluator = dict(ann_file=data_root + val_ann_file) +test_evaluator = val_evaluator +default_hooks = dict(logger=dict(interval=log_interval)) +##################### + +model = dict(bbox_head=dict(head_module=dict(num_classes=num_classes))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..0ab980ca7dfdd9c2feaba660f8745c92b49e6bbc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py @@ -0,0 +1,126 @@ +_base_ = '../yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' # noqa + +# ========================modified parameters====================== +# YOLOv5RandomAffine +use_mask2refine = True +max_aspect_ratio = 100 +min_area_ratio = 0.01 +# Polygon2Mask +downsample_ratio = 4 +mask_overlap = True +# LeterResize +# half_pad_param: if set to True, left and right pad_param will +# be given by dividing padding_h by 2. If set to False, pad_param is +# in int format. We recommend setting this to False for object +# detection tasks, and True for instance segmentation tasks. +# Default to False. +half_pad_param = True + +# Testing take a long time due to model_test_cfg. +# If you want to speed it up, you can increase score_thr +# or decraese nms_pre and max_per_img +model_test_cfg = dict( + multi_label=True, + nms_pre=30000, + min_bbox_size=0, + score_thr=0.001, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=300, + mask_thr_binary=0.5, + # fast_test: Whether to use fast test methods. When set + # to False, the implementation here is the same as the + # official, with higher mAP. If set to True, mask will first + # be upsampled to origin image shape through Pytorch, and + # then use mask_thr_binary to determine which pixels belong + # to the object. If set to False, will first use + # mask_thr_binary to determine which pixels belong to the + # object , and then use opencv to upsample mask to origin + # image shape. Default to False. + fast_test=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + bbox_head=dict( + type='YOLOv5InsHead', + head_module=dict( + type='YOLOv5InsHeadModule', mask_channels=32, proto_channels=256), + mask_overlap=mask_overlap, + loss_mask=dict( + type='mmdet.CrossEntropyLoss', use_sigmoid=True, reduction='none'), + loss_mask_weight=0.05), + test_cfg=model_test_cfg) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=use_mask2refine) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + max_aspect_ratio=max_aspect_ratio, + use_mask_refine=use_mask2refine), + # TODO: support mask transform in albu + # Geometric transformations are not supported in albu now. + dict( + type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='Polygon2Mask', + downsample_ratio=downsample_ratio, + mask_overlap=mask_overlap), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=False, + half_pad_param=half_pad_param, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict(metric=['bbox', 'segm']) +test_evaluator = val_evaluator diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..83b48cab69ade156f69864d11b37af597dd82da2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance.py @@ -0,0 +1,49 @@ +_base_ = './yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +# ========================modified parameters====================== +mask_overlap = False # Polygon2Mask + +# ===============================Unmodified in most cases==================== +model = dict(bbox_head=dict(mask_overlap=mask_overlap)) + +train_pipeline = [ + *_base_.pre_transform, + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + max_aspect_ratio=_base_.max_aspect_ratio, + use_mask_refine=True), + dict( + type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes', + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='Polygon2Mask', + downsample_ratio=_base_.downsample_ratio, + mask_overlap=mask_overlap), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance.py new file mode 100644 index 0000000000000000000000000000000000000000..a18170ccc30c541f583ca3f4eaf829b853ed2816 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance.py @@ -0,0 +1,15 @@ +_base_ = './yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +deepen_factor = 1.33 +widen_factor = 1.25 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..206eec3c41542958ae105764fbf3991935b30bc8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,77 @@ +_base_ = './yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py' + +# This config use refining bbox and `YOLOv5CopyPaste`. +# Refining bbox means refining bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 1.0 +widen_factor = 1.0 + +mixup_prob = 0.1 +copypaste_prob = 0.1 + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine), + dict(type='RemoveDataElement', keys=['gt_masks']) +] + +# enable mixup and copypaste +train_pipeline = [ + *pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..4af27a917e6113f33ff72781eeee911381bbed53 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,86 @@ +_base_ = './yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 +lr_factor = 0.1 +loss_cls_weight = 0.3 +loss_obj_weight = 0.7 + +affine_scale = 0.9 +mixup_prob = 0.1 + +# =======================Unmodified in most cases================== +num_classes = _base_.num_classes +num_det_layers = _base_.num_det_layers +img_scale = _base_.img_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)))) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine), + dict(type='RemoveDataElement', keys=['gt_masks']) +] + +# enable mixup +train_pipeline = [ + *pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..3fe8dc32ceaf687940596f6b8094d79857921deb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,20 @@ +_base_ = './yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.25 + +# ===============================Unmodified in most cases==================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..74febbb7764435d7ab4d9a8014fb6977a269da68 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,62 @@ +_base_ = '../yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +use_mask2refine = True +min_area_ratio = 0.01 # YOLOv5RandomAffine + +# ===============================Unmodified in most cases==================== +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=use_mask2refine) +] + +last_transform = [ + # Delete gt_masks to avoid more computation + dict(type='RemoveDataElement', keys=['gt_masks']), + dict( + type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), + *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..fb76f1057872d81f52ac9369a689545194a61bb7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py' + +# This config use refining bbox and `YOLOv5CopyPaste`. +# Refining bbox means refining bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 1.33 +widen_factor = 1.25 + +# ===============================Unmodified in most cases==================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..bfe5add4fa0f268a8a6566c7ddc2e9b46a92ffe7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/metafile.yml @@ -0,0 +1,346 @@ +Collections: + - Name: YOLOv5 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - AMP + - Synchronize BN + Training Resources: 8x A100 GPUs + Architecture: + - CSPDarkNet + - PAFPN + README: configs/yolov5/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.1.0/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.1.0 + - Name: YOLOv5_VOC + Metadata: + Training Data: VOC + Training Techniques: + - SGD with Nesterov + - Weight Decay + - AMP + Training Resources: 1x A100 GPU + Architecture: + - CSPDarkNet + - PAFPN + README: configs/yolov5/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.1.0/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.1.0 + +Models: + - Name: yolov5_n-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 1.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 28.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739-b804c1ad.pth + - Name: yolov5_s-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 2.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth + - Name: yolov5_m-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth + - Name: yolov5_l-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 8.1 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.8 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco/yolov5_l-v61_syncbn_fast_8xb16-300e_coco_20220917_031007-096ef0eb.pth + - Name: yolov5_x-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 12.2 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.2 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco/yolov5_x-v61_syncbn_fast_8xb16-300e_coco_20230305_152943-00776a4b.pth + - Name: yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 5.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 35.9 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_224705-d493c5f3.pth + - Name: yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 10.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.4 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_215044-58865c19.pth + - Name: yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 19.1 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_230453-49564d58.pth + - Name: yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 30.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 53.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_234308-7a2ba6bf.pth + - Name: yolov5_n-v61_fast_1xb64-50e_voc + In Collection: YOLOv5_VOC + Config: configs/yolov5/voc/yolov5_n-v61_fast_1xb64-50e_voc.py + Metadata: + Training Memory (GB): 3.5 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.2 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_fast_1xb64-50e_voc/yolov5_n-v61_fast_1xb64-50e_voc_20221017_234254-f1493430.pth + - Name: yolov5_s-v61_fast_1xb64-50e_voc + In Collection: YOLOv5_VOC + Config: configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py + Metadata: + Training Memory (GB): 6.5 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 62.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_fast_1xb64-50e_voc/yolov5_s-v61_fast_1xb64-50e_voc_20221017_234156-0009b33e.pth + - Name: yolov5_m-v61_fast_1xb64-50e_voc + In Collection: YOLOv5_VOC + Config: configs/yolov5/voc/yolov5_m-v61_fast_1xb64-50e_voc.py + Metadata: + Training Memory (GB): 12.0 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 70.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_fast_1xb64-50e_voc/yolov5_m-v61_fast_1xb64-50e_voc_20221017_114138-815c143a.pth + - Name: yolov5_l-v61_fast_1xb32-50e_voc + In Collection: YOLOv5_VOC + Config: configs/yolov5/voc/yolov5_l-v61_fast_1xb32-50e_voc.py + Metadata: + Training Memory (GB): 10.0 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 73.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_fast_1xb32-50e_voc/yolov5_l-v61_fast_1xb32-50e_voc_20221017_045500-edc7e0d8.pth + - Name: yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 1.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 28.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_n_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_152706-712fb1b2.pth + - Name: yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 2.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_s_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230304_033134-8e0cd271.pth + - Name: yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_m_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_153946-44e96155.pth + - Name: yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 8.1 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_l_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_154301-2c1d912a.pth + - Name: yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco + In Collection: YOLOv5 + Config: configs/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 12.2 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.9 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/mask_refine/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco/yolov5_x_mask-refine-v61_syncbn_fast_8xb16-300e_coco_20230305_154321-07edeb62.pth + - Name: yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance + In Collection: YOLOv5 + Config: configs/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance.py + Metadata: + Training Memory (GB): 3.3 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 27.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 23.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_n-v61_syncbn_fast_8xb16-300e_coco_instance_20230424_104807-84cc9240.pth + - Name: yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance + In Collection: YOLOv5 + Config: configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py + Metadata: + Training Memory (GB): 4.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 32.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance_20230426_012542-3e570436.pth + - Name: yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance + In Collection: YOLOv5 + Config: configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance.py + Metadata: + Training Memory (GB): 4.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 32.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance/yolov5_ins_s-v61_syncbn_fast_non_overlap_8xb16-300e_coco_instance_20230424_104642-6780d34e.pth + - Name: yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance + In Collection: YOLOv5 + Config: configs/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance.py + Metadata: + Training Memory (GB): 7.3 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_m-v61_syncbn_fast_8xb16-300e_coco_instance_20230424_111529-ef5ba1a9.pth + - Name: yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance + In Collection: YOLOv5 + Config: configs/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance.py + Metadata: + Training Memory (GB): 10.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.9 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_l-v61_syncbn_fast_8xb16-300e_coco_instance_20230508_104049-daa09f70.pth + - Name: yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance + In Collection: YOLOv5 + Config: configs/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance.py + Metadata: + Training Memory (GB): 15.0 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.4 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov5/ins_seg/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance/yolov5_ins_x-v61_syncbn_fast_8xb16-300e_coco_instance_20230508_103925-a260c798.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_l-v61_fast_1xb32-50e_voc.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_l-v61_fast_1xb32-50e_voc.py new file mode 100644 index 0000000000000000000000000000000000000000..4b470973c46073748803bac2f736eca615e3cb00 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_l-v61_fast_1xb32-50e_voc.py @@ -0,0 +1,25 @@ +_base_ = './yolov5_s-v61_fast_1xb64-50e_voc.py' + +deepen_factor = 1.0 +widen_factor = 1.0 +train_batch_size_per_gpu = 32 +train_num_workers = 8 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco/yolov5_l-v61_syncbn_fast_8xb16-300e_coco_20220917_031007-096ef0eb.pth' # noqa + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, num_workers=train_num_workers) + +optim_wrapper = dict( + optimizer=dict(batch_size_per_gpu=train_batch_size_per_gpu)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_m-v61_fast_1xb64-50e_voc.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_m-v61_fast_1xb64-50e_voc.py new file mode 100644 index 0000000000000000000000000000000000000000..2ed2127a19854fde1b6fa0c80f4d6fd2ba818f0a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_m-v61_fast_1xb64-50e_voc.py @@ -0,0 +1,17 @@ +_base_ = './yolov5_s-v61_fast_1xb64-50e_voc.py' + +deepen_factor = 0.67 +widen_factor = 0.75 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth' # noqa + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_n-v61_fast_1xb64-50e_voc.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_n-v61_fast_1xb64-50e_voc.py new file mode 100644 index 0000000000000000000000000000000000000000..041f6537d03a4f13402b1bb7e2665443793e4681 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_n-v61_fast_1xb64-50e_voc.py @@ -0,0 +1,17 @@ +_base_ = './yolov5_s-v61_fast_1xb64-50e_voc.py' + +deepen_factor = 0.33 +widen_factor = 0.25 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739-b804c1ad.pth' # noqa + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py new file mode 100644 index 0000000000000000000000000000000000000000..f777fff9697dfbd315a0b8f762a2bf31a1118ca8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py @@ -0,0 +1,270 @@ +_base_ = '../yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +# dataset settings +data_root = 'data/VOCdevkit/' +dataset_type = 'YOLOv5VOCDataset' + +# parameters that often need to be modified +num_classes = 20 +img_scale = (512, 512) # width, height +max_epochs = 50 +train_batch_size_per_gpu = 64 +train_num_workers = 8 +val_batch_size_per_gpu = 1 +val_num_workers = 2 + +# persistent_workers must be False if num_workers is 0. +persistent_workers = True + +lr_factor = 0.15135 +affine_scale = 0.75544 + +# only on Val +batch_shapes_cfg = dict(img_size=img_scale[0]) + +anchors = [[(26, 44), (67, 57), (61, 130)], [(121, 118), (120, 239), + (206, 182)], + [(376, 161), (234, 324), (428, 322)]] +num_det_layers = 3 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' # noqa + +tta_img_scales = [img_scale, (416, 416), (640, 640)] + +# Hyperparameter reference from: +# https://github.com/ultralytics/yolov5/blob/master/data/hyps/hyp.VOC.yaml +model = dict( + bbox_head=dict( + head_module=dict(num_classes=num_classes), + prior_generator=dict(base_sizes=anchors), + loss_cls=dict( + loss_weight=0.21638 * (num_classes / 80 * 3 / num_det_layers), + class_weight=0.5), + loss_bbox=dict(loss_weight=0.02 * (3 / num_det_layers)), + loss_obj=dict( + loss_weight=0.51728 * + ((img_scale[0] / 640)**2 * 3 / num_det_layers), + class_weight=0.67198), + # Different from COCO + prior_match_thr=3.3744), + test_cfg=dict(nms=dict(iou_threshold=0.6))) + +albu_train_transforms = _base_.albu_train_transforms +pre_transform = _base_.pre_transform + +with_mosiac_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.04591, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + dict( + type='YOLOv5MixUp', + prob=0.04266, + pre_transform=[ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.04591, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) + ]) +] + +without_mosaic_pipeline = [ + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.04591, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + border=(0, 0), + border_val=(114, 114, 114)), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114)) +] + +# Because the border parameter is inconsistent when +# using mosaic or not, `RandomChoice` is used here. +randchoice_mosaic_pipeline = dict( + type='RandomChoice', + transforms=[with_mosiac_pipeline, without_mosaic_pipeline], + prob=[0.85834, 0.14166]) + +train_pipeline = [ + *pre_transform, randchoice_mosaic_pipeline, + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict( + type='YOLOv5HSVRandomAug', + hue_delta=0.01041, + saturation_delta=0.54703, + value_delta=0.27739), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + _delete_=True, + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type='ConcatDataset', + datasets=[ + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2007/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline), + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2012/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2012/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline) + ], + # Use ignore_keys to avoid judging metainfo is + # not equal in `ConcatDataset`. + ignore_keys='dataset_type'), + collate_fn=dict(type='yolov5_collate')) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2007/ImageSets/Main/test.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + test_mode=True, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +param_scheduler = None +optim_wrapper = dict( + optimizer=dict( + lr=0.00334, + momentum=0.74832, + weight_decay=0.00025, + batch_size_per_gpu=train_batch_size_per_gpu)) + +default_hooks = dict( + param_scheduler=dict( + lr_factor=lr_factor, + max_epochs=max_epochs, + warmup_epochs=3.3835, + warmup_momentum=0.59462, + warmup_bias_lr=0.18657)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + # To load COCO pretrained model, need to set `strict_load=False` + strict_load=False, + priority=49) +] + +# TODO: Support using coco metric in voc dataset +val_evaluator = dict( + _delete_=True, type='mmdet.VOCMetric', metric='mAP', eval_mode='area') + +test_evaluator = val_evaluator + +train_cfg = dict(max_epochs=max_epochs) + +# Config for Test Time Augmentation. (TTA) +_multiscale_resize_transforms = [ + dict( + type='Compose', + transforms=[ + dict(type='YOLOv5KeepRatioResize', scale=s), + dict( + type='LetterResize', + scale=s, + allow_scale_up=False, + pad_val=dict(img=114)) + ]) for s in tta_img_scales +] + +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='TestTimeAug', + transforms=[ + _multiscale_resize_transforms, + [ + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'flip', + 'flip_direction')) + ] + ]) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_x-v61_fast_1xb32-50e_voc.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_x-v61_fast_1xb32-50e_voc.py new file mode 100644 index 0000000000000000000000000000000000000000..2fc4d79f86b40c45d3f7692f32adc88295bbb4a4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/voc/yolov5_x-v61_fast_1xb32-50e_voc.py @@ -0,0 +1,26 @@ +_base_ = './yolov5_s-v61_fast_1xb64-50e_voc.py' + +deepen_factor = 1.33 +widen_factor = 1.25 +train_batch_size_per_gpu = 32 +train_num_workers = 8 + +# TODO: need to add pretrained_model +load_from = None + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, num_workers=train_num_workers) + +optim_wrapper = dict( + optimizer=dict(batch_size_per_gpu=train_batch_size_per_gpu)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..6a84fdbebc11dd4eafadc34be1e98bfb6f9b2f43 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,15 @@ +_base_ = './yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py' + +deepen_factor = 1.0 +widen_factor = 1.0 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..60a11a375c3dd8ead1d3f6a04340aed2acb20b20 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,15 @@ +_base_ = './yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py' + +deepen_factor = 1.0 +widen_factor = 1.0 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..f593e378a9fbbf1381e48a186a645a559b1f129a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,79 @@ +_base_ = './yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 +lr_factor = 0.1 +affine_scale = 0.9 +loss_cls_weight = 0.3 +loss_obj_weight = 0.7 +mixup_prob = 0.1 + +# =======================Unmodified in most cases================== +num_classes = _base_.num_classes +num_det_layers = _base_.num_det_layers +img_scale = _base_.img_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)))) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +# enable mixup +train_pipeline = [ + *pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..d2ef324ed097a30d5a04fba2bb85641e7857f353 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,79 @@ +_base_ = './yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 +lr_factor = 0.1 +affine_scale = 0.9 +loss_cls_weight = 0.3 +loss_obj_weight = 0.7 +mixup_prob = 0.1 + +# =======================Unmodified in most cases================== +num_classes = _base_.num_classes +num_det_layers = _base_.num_det_layers +img_scale = _base_.img_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)))) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +# enable mixup +train_pipeline = [ + *pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..3cd2d6b7be817f4f8e6729acc1d3f9e450457e07 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,15 @@ +_base_ = 'yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py' + +deepen_factor = 0.33 +widen_factor = 0.25 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b6f93428fc8d6dc1b94a8d447671ffc1a877dbb8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,15 @@ +_base_ = './yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +deepen_factor = 0.33 +widen_factor = 0.25 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..f64df69fd4ea0f4c8d30b9e8928bcd1c4e1d9d35 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,138 @@ +_base_ = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +img_scale = (1280, 1280) # width, height +num_classes = 80 # Number of classes for classification +# Config of batch shapes. Only on val. +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + img_size=img_scale[0], + # The image scale of padding should be divided by pad_size_divisor + size_divisor=64) +# Basic size of multi-scale prior box +anchors = [ + [(19, 27), (44, 40), (38, 94)], # P3/8 + [(96, 68), (86, 152), (180, 137)], # P4/16 + [(140, 301), (303, 264), (238, 542)], # P5/32 + [(436, 615), (739, 380), (925, 792)] # P6/64 +] +# Strides of multi-scale prior box +strides = [8, 16, 32, 64] +num_det_layers = 4 # The number of model output scales +loss_cls_weight = 0.5 +loss_bbox_weight = 0.05 +loss_obj_weight = 1.0 +# The obj loss weights of the three output layers +obj_level_weights = [4.0, 1.0, 0.25, 0.06] +affine_scale = 0.5 # YOLOv5RandomAffine scaling ratio + +tta_img_scales = [(1280, 1280), (1024, 1024), (1536, 1536)] +# =======================Unmodified in most cases================== +model = dict( + backbone=dict(arch='P6', out_indices=(2, 3, 4, 5)), + neck=dict( + in_channels=[256, 512, 768, 1024], out_channels=[256, 512, 768, 1024]), + bbox_head=dict( + head_module=dict( + in_channels=[256, 512, 768, 1024], featmap_strides=strides), + prior_generator=dict(base_sizes=anchors, strides=strides), + # scaled based on number of detection layers + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_bbox=dict(loss_weight=loss_bbox_weight * (3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)), + obj_level_weights=obj_level_weights)) + +pre_transform = _base_.pre_transform +albu_train_transforms = _base_.albu_train_transforms + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +# Config for Test Time Augmentation. (TTA) +_multiscale_resize_transforms = [ + dict( + type='Compose', + transforms=[ + dict(type='YOLOv5KeepRatioResize', scale=s), + dict( + type='LetterResize', + scale=s, + allow_scale_up=False, + pad_val=dict(img=114)) + ]) for s in tta_img_scales +] + +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='TestTimeAug', + transforms=[ + _multiscale_resize_transforms, + [ + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'flip', + 'flip_direction')) + ] + ]) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_608x352_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_608x352_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..5bbd13e0859abb7a9fa315a8b0f956f959a560d7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_608x352_cat.py @@ -0,0 +1,70 @@ +_base_ = 'yolov5_s-v61_fast_1xb12-40e_cat.py' + +# This configuration is used to provide non-square training examples +# Must be a multiple of 32 +img_scale = (608, 352) # w h + +anchors = [ + [(65, 35), (159, 45), (119, 80)], # P3/8 + [(215, 77), (224, 116), (170, 166)], # P4/16 + [(376, 108), (339, 176), (483, 190)] # P5/32 +] + +# ===============================Unmodified in most cases==================== +_base_.model.bbox_head.loss_obj.loss_weight = 1.0 * ((img_scale[1] / 640)**2) +_base_.model.bbox_head.prior_generator.base_sizes = anchors + +train_pipeline = [ + *_base_.pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + dict( + type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +_base_.train_dataloader.dataset.pipeline = train_pipeline + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='mmdet.LoadAnnotations', with_bbox=True), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) +test_dataloader = val_dataloader diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..7b7e4f227bbc6aa37873dc306009d1af842c166c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py @@ -0,0 +1,56 @@ +_base_ = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +anchors = [ + [(68, 69), (154, 91), (143, 162)], # P3/8 + [(242, 160), (189, 287), (391, 207)], # P4/16 + [(353, 337), (539, 341), (443, 432)] # P5/32 +] + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 4 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict( + head_module=dict(num_classes=num_classes), + prior_generator=dict(base_sizes=anchors))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +_base_.optim_wrapper.optimizer.batch_size_per_gpu = train_batch_size_per_gpu + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + # The warmup_mim_iter parameter is critical. + # The default value is 1000 which is not suitable for cat datasets. + param_scheduler=dict(max_epochs=max_epochs, warmup_mim_iter=10), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-ms-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-ms-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..dc460fa9802d34ece214482bcda7a6bdf7435b39 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_fast_1xb12-ms-40e_cat.py @@ -0,0 +1,13 @@ +_base_ = 'yolov5_s-v61_fast_1xb12-40e_cat.py' + +model = dict( + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + random_size_range=(480, 800), + size_divisor=32, + interval=1) + ])) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn-detect_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn-detect_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..d8238c1377cb2f56f4c3bf0c5cd6d4227b2d70a5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn-detect_8xb16-300e_coco.py @@ -0,0 +1,23 @@ +_base_ = 'yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + use_mini_pad=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) +test_dataloader = val_dataloader + +model = dict( + test_cfg=dict( + multi_label=False, score_thr=0.25, nms=dict(iou_threshold=0.45))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..7e81a0385587df40c588dcb44202a7f5d82478c1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py @@ -0,0 +1,292 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 16 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----model related----- +# Basic size of multi-scale prior box +anchors = [ + [(10, 13), (16, 30), (33, 23)], # P3/8 + [(30, 61), (62, 45), (59, 119)], # P4/16 + [(116, 90), (156, 198), (373, 326)] # P5/32 +] + +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 8xb16=128 bs +base_lr = 0.01 +max_epochs = 300 # Maximum training epochs + +model_test_cfg = dict( + # The config of multi-label for multi-class prediction. + multi_label=True, + # The number of boxes before NMS + nms_pre=30000, + score_thr=0.001, # Threshold to filter out boxes. + nms=dict(type='nms', iou_threshold=0.65), # NMS type and threshold + max_per_img=300) # Max number of detections of each image + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# Config of batch shapes. Only on val. +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + # The image scale of padding should be divided by pad_size_divisor + size_divisor=32, + # Additional paddings for pixel scale + extra_pad_ratio=0.5) + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.5 +# Strides of multi-scale prior box +strides = [8, 16, 32] +num_det_layers = 3 # The number of model output scales +norm_cfg = dict(type='BN', momentum=0.03, eps=0.001) # Normalization config + +# -----train val related----- +affine_scale = 0.5 # YOLOv5RandomAffine scaling ratio +loss_cls_weight = 0.5 +loss_bbox_weight = 0.05 +loss_obj_weight = 1.0 +prior_match_thr = 4. # Priori box matching threshold +# The obj loss weights of the three output layers +obj_level_weights = [4., 1., 0.4] +lr_factor = 0.01 # Learning rate scaling factor +weight_decay = 0.0005 +# Save model checkpoint and validation intervals +save_checkpoint_intervals = 10 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 +# Single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='mmdet.DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='YOLOv5CSPDarknet', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=[256, 512, 1024], + num_csp_blocks=3, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + num_classes=num_classes, + in_channels=[256, 512, 1024], + widen_factor=widen_factor, + featmap_strides=strides, + num_base_priors=3), + prior_generator=dict( + type='mmdet.YOLOAnchorGenerator', + base_sizes=anchors, + strides=strides), + # scaled based on number of detection layers + loss_cls=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_bbox=dict( + type='IoULoss', + iou_mode='ciou', + bbox_format='xywh', + eps=1e-7, + reduction='mean', + loss_weight=loss_bbox_weight * (3 / num_det_layers), + return_iou=True), + loss_obj=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)), + prior_match_thr=prior_match_thr, + obj_level_weights=obj_level_weights), + test_cfg=model_test_cfg) + +albu_train_transforms = [ + dict(type='Blur', p=0.01), + dict(type='MedianBlur', p=0.01), + dict(type='ToGray', p=0.01), + dict(type='CLAHE', p=0.01) +] + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +param_scheduler = None +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.937, + weight_decay=weight_decay, + nesterov=True, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOv5OptimizerConstructor') + +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='linear', + lr_factor=lr_factor, + max_epochs=max_epochs), + checkpoint=dict( + type='CheckpointHook', + interval=save_checkpoint_intervals, + save_best='auto', + max_keep_ckpts=max_keep_ckpts)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_checkpoint_intervals) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_fast_1xb4-300e_balloon.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_fast_1xb4-300e_balloon.py new file mode 100644 index 0000000000000000000000000000000000000000..2c585ceb92e9bfb1984b49ce02f86f4d3cd4532d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_fast_1xb4-300e_balloon.py @@ -0,0 +1,42 @@ +_base_ = './yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +data_root = 'data/balloon/' +# Path of train annotation file +train_ann_file = 'train.json' +train_data_prefix = 'train/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'val.json' +val_data_prefix = 'val/' # Prefix of val image path +metainfo = { + 'classes': ('balloon', ), + 'palette': [ + (220, 20, 60), + ] +} +num_classes = 1 + +train_batch_size_per_gpu = 4 +train_num_workers = 2 +log_interval = 1 + +# =======================Unmodified in most cases================== +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + data_prefix=dict(img=train_data_prefix), + ann_file=train_ann_file)) +val_dataloader = dict( + dataset=dict( + data_root=data_root, + metainfo=metainfo, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file)) +test_dataloader = val_dataloader +val_evaluator = dict(ann_file=data_root + val_ann_file) +test_evaluator = val_evaluator +model = dict(bbox_head=dict(head_module=dict(num_classes=num_classes))) +default_hooks = dict(logger=dict(interval=log_interval)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..17b4a73b092fda1b98a088a83619697702859f71 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,12 @@ +_base_ = 'yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +# fast means faster training speed, +# but less flexibility for multitasking +model = dict( + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True)) + +train_dataloader = dict(collate_fn=dict(type='yolov5_collate')) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_x-p6-v62_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_x-p6-v62_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..9fe5c0103520280ba26bb3f56a4a30658576b74b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_x-p6-v62_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,14 @@ +_base_ = './yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py' +deepen_factor = 1.33 +widen_factor = 1.25 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8782eed8df6318b3aad6333809a04f639fd0cefb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5_x-v61_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,14 @@ +_base_ = './yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py' +deepen_factor = 1.33 +widen_factor = 1.25 + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_l_mask-refine_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_l_mask-refine_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..60c11feb3d4e6f8db5f3e70af5d3afdbc5f65535 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_l_mask-refine_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,59 @@ +_base_ = './yolov5u_m_mask-refine_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 1.00 +widen_factor = 1.00 + +mixup_prob = 0.15 +copypaste_prob = 0.3 + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform +last_transform = _base_.last_transform +affine_scale = _base_.affine_scale + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +mosaic_affine_transform = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] + +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_l_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_l_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..22b9e881d024bfc781b1328913b50439ac80a2f3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_l_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,18 @@ +_base_ = './yolov5u_s_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +# TODO: Update the training hyperparameters +deepen_factor = 1.0 +widen_factor = 1.0 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_m_mask-refine_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_m_mask-refine_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..ecc86fdd2d9ae362477f4edc5e5f9dd497222946 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_m_mask-refine_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,79 @@ +_base_ = './yolov5u_s_mask-refine_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +affine_scale = 0.9 +mixup_prob = 0.1 +copypaste_prob = 0.1 + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform +last_transform = _base_.last_transform + +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +mosaic_affine_transform = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] + +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine), *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +_base_.custom_hooks[1].switch_pipeline = train_pipeline_stage2 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_m_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_m_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..0cfb332488ba41c5e0880bd91d8c73fccde52f36 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_m_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,18 @@ +_base_ = './yolov5u_s_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +# TODO: Update the training hyperparameters +deepen_factor = 0.67 +widen_factor = 0.75 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_n_mask-refine_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_n_mask-refine_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..1ca21b65147e830b04b0e70e61011f6a9371d637 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_n_mask-refine_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,20 @@ +_base_ = './yolov5u_s_mask-refine_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.25 + +# ===============================Unmodified in most cases==================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_n_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_n_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..ad6a9f2eba7ac8fc56c12fab52a3a8f9b24acba1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_n_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,17 @@ +_base_ = './yolov5u_s_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.25 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_s_mask-refine_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_s_mask-refine_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..d6840bc288b2cb9d26ebc06d0b888926035ce8b9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_s_mask-refine_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,80 @@ +_base_ = './yolov5u_s_syncbn_fast_8xb16-300e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +use_mask2refine = True +min_area_ratio = 0.01 # YOLOv5RandomAffine + +# ===============================Unmodified in most cases==================== +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=use_mask2refine) +] + +last_transform = [ + # Delete gt_masks to avoid more computation + dict(type='RemoveDataElement', keys=['gt_masks']), + dict( + type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114)), *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +_base_.custom_hooks[1].switch_pipeline = train_pipeline_stage2 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_s_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_s_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..81d3a981c281af0f4cd9596c4a7349cb2e1bf367 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_s_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,326 @@ +_base_ = ['../../_base_/default_runtime.py', '../../_base_/det_p5_tta.py'] + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 16 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 8xb16=128 bs +base_lr = 0.01 +max_epochs = 300 # Maximum training epochs +# Disable mosaic augmentation for final 10 epochs (stage 2) +close_mosaic_epochs = 10 + +model_test_cfg = dict( + # The config of multi-label for multi-class prediction. + multi_label=True, + # The number of boxes before NMS + nms_pre=30000, + score_thr=0.001, # Threshold to filter out boxes. + nms=dict(type='nms', iou_threshold=0.7), # NMS type and threshold + max_per_img=300) # Max number of detections of each image + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# Config of batch shapes. Only on val. +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + # The image scale of padding should be divided by pad_size_divisor + size_divisor=32, + # Additional paddings for pixel scale + extra_pad_ratio=0.5) + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.5 +# Strides of multi-scale prior box +strides = [8, 16, 32] +num_det_layers = 3 # The number of model output scales +norm_cfg = dict(type='BN', momentum=0.03, eps=0.001) # Normalization config + +# -----train val related----- +tal_topk = 10 # Number of bbox selected in each level +tal_alpha = 0.5 # A Hyper-parameter related to alignment_metrics +tal_beta = 6.0 # A Hyper-parameter related to alignment_metrics + +affine_scale = 0.5 # YOLOv5RandomAffine scaling ratio +# YOLOv5RandomAffine aspect ratio of width and height thres to filter bboxes +max_aspect_ratio = 100 +# TODO: Automatically scale loss_weight based on number of detection layers +loss_cls_weight = 0.5 +loss_bbox_weight = 7.5 +# Since the dfloss is implemented differently in the official +# and mmdet, we're going to divide loss_weight by 4. +loss_dfl_weight = 1.5 / 4 +lr_factor = 0.01 # Learning rate scaling factor +weight_decay = 0.001 +# Save model checkpoint and validation intervals +save_checkpoint_intervals = 10 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 +# Single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='YOLOv5CSPDarknet', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=[256, 512, 1024], + num_csp_blocks=3, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='YOLOv8Head', + head_module=dict( + type='YOLOv8HeadModule', + num_classes=num_classes, + in_channels=[256, 512, 1024], + widen_factor=widen_factor, + reg_max=16, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + featmap_strides=strides), + prior_generator=dict( + type='mmdet.MlvlPointGenerator', offset=0.5, strides=strides), + bbox_coder=dict(type='DistancePointBBoxCoder'), + # scaled based on number of detection layers + loss_cls=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none', + loss_weight=loss_cls_weight), + loss_bbox=dict( + type='IoULoss', + iou_mode='ciou', + bbox_format='xyxy', + reduction='sum', + loss_weight=loss_bbox_weight, + return_iou=False), + loss_dfl=dict( + type='mmdet.DistributionFocalLoss', + reduction='mean', + loss_weight=loss_dfl_weight)), + train_cfg=dict( + assigner=dict( + type='BatchTaskAlignedAssigner', + num_classes=num_classes, + use_ciou=True, + topk=tal_topk, + alpha=tal_alpha, + beta=tal_beta, + eps=1e-9)), + test_cfg=model_test_cfg) + +albu_train_transforms = [ + dict(type='Blur', p=0.01), + dict(type='MedianBlur', p=0.01), + dict(type='ToGray', p=0.01), + dict(type='CLAHE', p=0.01) +] + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +last_transform = [ + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=max_aspect_ratio, + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=max_aspect_ratio, + border_val=(114, 114, 114)), *last_transform +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + collate_fn=dict(type='yolov5_collate'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +param_scheduler = None +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.937, + weight_decay=weight_decay, + nesterov=True, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOv5OptimizerConstructor') + +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='linear', + lr_factor=lr_factor, + max_epochs=max_epochs, + warmup_epochs=3.0, + warmup_momentum=0.8, + warmup_bias_lr=0.1), + checkpoint=dict( + type='CheckpointHook', + interval=save_checkpoint_intervals, + save_best='auto', + max_keep_ckpts=max_keep_ckpts)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_checkpoint_intervals) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_x_mask-refine_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_x_mask-refine_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..33092aa6a47e6053c8ce83dcdf820828619077bc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_x_mask-refine_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,17 @@ +_base_ = './yolov5u_l_mask-refine_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 1.33 +widen_factor = 1.25 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_x_syncbn_fast_8xb16-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_x_syncbn_fast_8xb16-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..fd471fd46f3e19c4e0a4176703d4ab5eeee3aa0b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov5/yolov5u/yolov5u_x_syncbn_fast_8xb16-300e_coco.py @@ -0,0 +1,18 @@ +_base_ = './yolov5u_l_syncbn_fast_8xb16-300e_coco.py' + +# ========================modified parameters====================== +# TODO: Update the training hyperparameters +deepen_factor = 1.33 +widen_factor = 1.25 + +# =======================Unmodified in most cases================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7ecda276988ff87702e902be8799d85b2dfdc79f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/README.md @@ -0,0 +1,53 @@ +# YOLOv6 + +> [YOLOv6: A Single-Stage Object Detection Framework for Industrial Applications](https://arxiv.org/abs/2209.02976) + + + +## Abstract + +For years, YOLO series have been de facto industry-level standard for efficient object detection. The YOLO community has prospered overwhelmingly to enrich its use in a multitude of hardware platforms and abundant scenarios. In this technical report, we strive to push its limits to the next level, stepping forward with an unwavering mindset for industry application. Considering the diverse requirements for speed and accuracy in the real environment, we extensively examine the up-to-date object detection advancements either from industry or academy. Specifically, we heavily assimilate ideas from recent network design, training strategies, testing techniques, quantization and optimization methods. On top of this, we integrate our thoughts and practice to build a suite of deployment-ready networks at various scales to accommodate diversified use cases. With the generous permission of YOLO authors, we name it YOLOv6. We also express our warm welcome to users and contributors for further enhancement. For a glimpse of performance, our YOLOv6-N hits 35.9% AP on COCO dataset at a throughput of 1234 FPS on an NVIDIA Tesla T4 GPU. YOLOv6-S strikes 43.5% AP at 495 FPS, outperforming other mainstream detectors at the same scale (YOLOv5-S, YOLOX-S and PPYOLOE-S). Our quantized version of YOLOv6-S even brings a new state-of-the-art 43.3% AP at 869 FPS. Furthermore, YOLOv6-M/L also achieves better accuracy performance (i.e., 49.5%/52.3%) than other detectors with the similar inference speed. We carefully conducted experiments to validate the effectiveness of each component. + +
+ +
+ +
+YOLOv6-s +YOLOv6-s model structure +
+ +
+YOLOv6-l +YOLOv6-l model structure +
+ +## Results and models + +### COCO + +| Backbone | Arch | Size | Epoch | SyncBN | AMP | Mem (GB) | Box AP | Config | Download | +| :------: | :--: | :--: | :---: | :----: | :-: | :------: | :----: | :-------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOv6-n | P5 | 640 | 400 | Yes | Yes | 6.04 | 36.2 | [config](./yolov6_n_syncbn_fast_8xb32-400e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco/yolov6_n_syncbn_fast_8xb32-400e_coco_20221030_202726-d99b2e82.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco/yolov6_n_syncbn_fast_8xb32-400e_coco_20221030_202726.log.json) | +| YOLOv6-t | P5 | 640 | 400 | Yes | Yes | 8.13 | 41.0 | [config](./yolov6_t_syncbn_fast_8xb32-400e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco/yolov6_t_syncbn_fast_8xb32-400e_coco_20221030_143755-cf0d278f.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco/yolov6_t_syncbn_fast_8xb32-400e_coco_20221030_143755.log.json) | +| YOLOv6-s | P5 | 640 | 400 | Yes | Yes | 8.88 | 44.0 | [config](./yolov6_s_syncbn_fast_8xb32-400e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035-932e1d91.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035.log.json) | +| YOLOv6-m | P5 | 640 | 300 | Yes | Yes | 16.69 | 48.4 | [config](./yolov6_m_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco/yolov6_m_syncbn_fast_8xb32-300e_coco_20221109_182658-85bda3f4.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco/yolov6_m_syncbn_fast_8xb32-300e_coco_20221109_182658.log.json) | +| YOLOv6-l | P5 | 640 | 300 | Yes | Yes | 20.86 | 51.0 | [config](./yolov6_l_syncbn_fast_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco/yolov6_l_syncbn_fast_8xb32-300e_coco_20221109_183156-91e3c447.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco/yolov6_l_syncbn_fast_8xb32-300e_coco_20221109_183156.log.json) | + +**Note**: + +1. The official m and l models use knowledge distillation, but our version does not support it, which will be implemented in [MMRazor](https://github.com/open-mmlab/mmrazor) in the future. +2. The performance is unstable and may fluctuate by about 0.3 mAP. +3. If users need the weight of 300 epoch for nano, tiny and small model, they can train according to the configs of 300 epoch provided by us, or convert the official weight according to the [converter script](../../tools/model_converters/). +4. We have observed that the [base model](https://github.com/meituan/YOLOv6/tree/main/configs/base) has been officially released in v6 recently. Although the accuracy has decreased, it is more efficient. We will also provide the base model configuration in the future. + +## Citation + +```latex +@article{li2022yolov6, + title={YOLOv6: A Single-Stage Object Detection Framework for Industrial Applications}, + author={Li, Chuyi and Li, Lulu and Jiang, Hongliang and Weng, Kaiheng and Geng, Yifei and Li, Liang and Ke, Zaidan and Li, Qingyuan and Cheng, Meng and Nie, Weiqiang and others}, + journal={arXiv preprint arXiv:2209.02976}, + year={2022} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..df451526957c08d5956db33fe5e180cd7d5fcd66 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/metafile.yml @@ -0,0 +1,83 @@ +Collections: + - Name: YOLOv6 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - AMP + - Synchronize BN + Training Resources: 8x A100 GPUs + Architecture: + - CSPDarkNet + - PAFPN + - RepVGG + Paper: + URL: https://arxiv.org/abs/2209.02976 + Title: 'YOLOv6: A Single-Stage Object Detection Framework for Industrial Applications' + README: configs/yolov6/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.0.1/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.0.1 + +Models: + - Name: yolov6_s_syncbn_fast_8xb32-400e_coco + In Collection: YOLOv6 + Config: configs/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py + Metadata: + Training Memory (GB): 8.88 + Epochs: 400 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035-932e1d91.pth + - Name: yolov6_n_syncbn_fast_8xb32-400e_coco + In Collection: YOLOv6 + Config: configs/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco.py + Metadata: + Training Memory (GB): 6.04 + Epochs: 400 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.2 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco/yolov6_n_syncbn_fast_8xb32-400e_coco_20221030_202726-d99b2e82.pth + - Name: yolov6_t_syncbn_fast_8xb32-400e_coco + In Collection: YOLOv6 + Config: configs/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco.py + Metadata: + Training Memory (GB): 8.13 + Epochs: 400 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco/yolov6_t_syncbn_fast_8xb32-400e_coco_20221030_143755-cf0d278f.pth + - Name: yolov6_m_syncbn_fast_8xb32-300e_coco + In Collection: YOLOv6 + Config: configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 16.69 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.4 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco/yolov6_m_syncbn_fast_8xb32-300e_coco_20221109_182658-85bda3f4.pth + - Name: yolov6_l_syncbn_fast_8xb32-300e_coco + In Collection: YOLOv6 + Config: configs/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 20.86 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco/yolov6_l_syncbn_fast_8xb32-300e_coco_20221109_183156-91e3c447.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..ad5ecf347e4aa0b3194b8be33d9c294915dd9e56 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_l_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,28 @@ +_base_ = './yolov6_m_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 1 +# The scaling factor that controls the width of the network structure +widen_factor = 1 + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + hidden_ratio=1. / 2, + block_cfg=dict( + type='ConvWrapper', + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001)), + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + hidden_ratio=1. / 2, + block_cfg=dict( + type='ConvWrapper', + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001)), + block_act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..09811c8c06fb81a061ac4da7904c8d7d1e248411 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,62 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.6 +# The scaling factor that controls the width of the network structure +widen_factor = 0.75 + +# -----train val related----- +affine_scale = 0.9 # YOLOv5RandomAffine scaling ratio + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict( + type='YOLOv6CSPBep', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + hidden_ratio=2. / 3, + block_cfg=dict(type='RepVGGBlock'), + act_cfg=dict(type='ReLU', inplace=True)), + neck=dict( + type='YOLOv6CSPRepPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + block_cfg=dict(type='RepVGGBlock'), + hidden_ratio=2. / 3, + block_act_cfg=dict(type='ReLU', inplace=True)), + bbox_head=dict( + type='YOLOv6Head', head_module=dict(widen_factor=widen_factor))) + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=0.1, + pre_transform=[*_base_.pre_transform, *mosaic_affine_pipeline]), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_n_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_n_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..bc2db4b6c03277a7c62ba3ed505d54f54267328f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_n_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.25 + +# -----train val related----- +lr_factor = 0.02 # Learning rate scaling factor + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_bbox=dict(iou_mode='siou'))) + +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..f66aa15fc447bce5f510a60bdda1914a8a7b5a76 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_n_syncbn_fast_8xb32-400e_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-400e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.25 + +# -----train val related----- +lr_factor = 0.02 # Learning rate scaling factor + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_bbox=dict(iou_mode='siou'))) + +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_fast_1xb12-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_fast_1xb12-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..82578fccf7fffb8e4bb4ac21170543a7f71bc63e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_fast_1xb12-40e_cat.py @@ -0,0 +1,56 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-400e_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 4 +num_last_epochs = 5 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035-932e1d91.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict(head_module=dict(num_classes=num_classes)), + train_cfg=dict( + initial_assigner=dict(num_classes=num_classes), + assigner=dict(num_classes=num_classes))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +_base_.optim_wrapper.optimizer.batch_size_per_gpu = train_batch_size_per_gpu +_base_.custom_hooks[1].switch_epoch = max_epochs - num_last_epochs + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + # The warmup_mim_iter parameter is critical. + # The default value is 1000 which is not suitable for cat datasets. + param_scheduler=dict(max_epochs=max_epochs, warmup_mim_iter=10), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict( + max_epochs=max_epochs, + val_interval=10, + dynamic_intervals=[(max_epochs - num_last_epochs, 1)]) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..dbffaeb3362883d8a70f43c0722dd6c99b8b8352 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,33 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-400e_coco.py' + +# ======================= Frequently modified parameters ===================== +# -----train val related----- +# Base learning rate for optim_wrapper +max_epochs = 300 # Maximum training epochs +num_last_epochs = 15 # Last epoch number to switch training pipeline + +# ============================== Unmodified in most cases =================== +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='cosine', + lr_factor=0.01, + max_epochs=max_epochs)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - num_last_epochs, + switch_pipeline=_base_.train_pipeline_stage2) +] + +train_cfg = dict( + max_epochs=max_epochs, + dynamic_intervals=[(max_epochs - num_last_epochs, 1)]) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..eb564c07a906185f6702aac88cbb4d53493f168c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py @@ -0,0 +1,280 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# ======================= Frequently modified parameters ===================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 32 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper +base_lr = 0.01 +max_epochs = 400 # Maximum training epochs +num_last_epochs = 15 # Last epoch number to switch training pipeline + +# ======================= Possible modified parameters ======================= +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# Config of batch shapes. Only on val. +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + size_divisor=32, + extra_pad_ratio=0.5) + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.5 + +# -----train val related----- +affine_scale = 0.5 # YOLOv5RandomAffine scaling ratio +lr_factor = 0.01 # Learning rate scaling factor +weight_decay = 0.0005 +# Save model checkpoint and validation intervals +save_epoch_intervals = 10 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 +# Single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ============================== Unmodified in most cases =================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='YOLOv6EfficientRep', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True)), + neck=dict( + type='YOLOv6RepPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=[128, 256, 512], + num_csp_blocks=12, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True), + ), + bbox_head=dict( + type='YOLOv6Head', + head_module=dict( + type='YOLOv6HeadModule', + num_classes=num_classes, + in_channels=[128, 256, 512], + widen_factor=widen_factor, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='SiLU', inplace=True), + featmap_strides=[8, 16, 32]), + loss_bbox=dict( + type='IoULoss', + iou_mode='giou', + bbox_format='xyxy', + reduction='mean', + loss_weight=2.5, + return_iou=False)), + train_cfg=dict( + initial_epoch=4, + initial_assigner=dict( + type='BatchATSSAssigner', + num_classes=num_classes, + topk=9, + iou_calculator=dict(type='mmdet.BboxOverlaps2D')), + assigner=dict( + type='BatchTaskAlignedAssigner', + num_classes=num_classes, + topk=13, + alpha=1, + beta=6), + ), + test_cfg=dict( + multi_label=True, + nms_pre=30000, + score_thr=0.001, + nms=dict(type='nms', iou_threshold=0.65), + max_per_img=300)) + +# The training pipeline of YOLOv6 is basically the same as YOLOv5. +# The difference is that Mosaic and RandomAffine will be closed in the last 15 epochs. # noqa +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.1, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + max_shear_degree=0.0), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.1, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_shear_degree=0.0, + ), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + collate_fn=dict(type='yolov5_collate'), + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +# Optimizer and learning rate scheduler of YOLOv6 are basically the same as YOLOv5. # noqa +# The difference is that the scheduler_type of YOLOv6 is cosine. +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.937, + weight_decay=weight_decay, + nesterov=True, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOv5OptimizerConstructor') + +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='cosine', + lr_factor=lr_factor, + max_epochs=max_epochs), + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + max_keep_ckpts=max_keep_ckpts, + save_best='auto')) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - num_last_epochs, + switch_pipeline=train_pipeline_stage2) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_epoch_intervals, + dynamic_intervals=[(max_epochs - num_last_epochs, 1)]) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..aa9da63f6984a9a23bc7ca78780db5be5a782399 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,17 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.375 + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict( + type='YOLOv6Head', + head_module=dict(widen_factor=widen_factor), + loss_bbox=dict(iou_mode='siou'))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..75755555a58b45309df9213b6262cee030e41a9d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_t_syncbn_fast_8xb32-400e_coco.py @@ -0,0 +1,17 @@ +_base_ = './yolov6_s_syncbn_fast_8xb32-400e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.375 + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict( + type='YOLOv6Head', + head_module=dict(widen_factor=widen_factor), + loss_bbox=dict(iou_mode='siou'))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_l_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_l_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..7ed4b05538c077d6f49036c6399942d5f8b3f627 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_l_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,28 @@ +_base_ = './yolov6_v3_m_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 1 +# The scaling factor that controls the width of the network structure +widen_factor = 1 + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + hidden_ratio=1. / 2, + block_cfg=dict( + type='ConvWrapper', + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001)), + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + hidden_ratio=1. / 2, + block_cfg=dict( + type='ConvWrapper', + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001)), + block_act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_m_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_m_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..982b0c8865a557c9970c1f50e3b84acba89bf93f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_m_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,63 @@ +_base_ = './yolov6_v3_s_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.6 +# The scaling factor that controls the width of the network structure +widen_factor = 0.75 + +# -----train val related----- +affine_scale = 0.9 # YOLOv5RandomAffine scaling ratio + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict( + type='YOLOv6CSPBep', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + hidden_ratio=2. / 3, + block_cfg=dict(type='RepVGGBlock'), + act_cfg=dict(type='ReLU', inplace=True)), + neck=dict( + type='YOLOv6CSPRepBiPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + block_cfg=dict(type='RepVGGBlock'), + hidden_ratio=2. / 3, + block_act_cfg=dict(type='ReLU', inplace=True)), + bbox_head=dict( + type='YOLOv6Head', + head_module=dict(reg_max=16, widen_factor=widen_factor))) + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=_base_.pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +train_pipeline = [ + *_base_.pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=0.1, + pre_transform=[*_base_.pre_transform, *mosaic_affine_pipeline]), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_n_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_n_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..96469f026e253b76a293f8f3ef81148af5d258a8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_n_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolov6_v3_s_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.25 + +# -----train val related----- +lr_factor = 0.02 # Learning rate scaling factor + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict( + head_module=dict(widen_factor=widen_factor), + loss_bbox=dict(iou_mode='siou'))) + +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_s_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_s_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8b0ad190139fa199918752cb8b531352db942fc0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_s_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,282 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# ======================= Frequently modified parameters ===================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 32 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper +base_lr = 0.01 +max_epochs = 300 # Maximum training epochs +num_last_epochs = 15 # Last epoch number to switch training pipeline + +# ======================= Possible modified parameters ======================= +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# Config of batch shapes. Only on val. +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + size_divisor=32, + extra_pad_ratio=0.5) + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.5 + +# -----train val related----- +affine_scale = 0.5 # YOLOv5RandomAffine scaling ratio +lr_factor = 0.01 # Learning rate scaling factor +weight_decay = 0.0005 +# Save model checkpoint and validation intervals +save_epoch_intervals = 10 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 +# Single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ============================== Unmodified in most cases =================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='YOLOv6EfficientRep', + out_indices=[1, 2, 3, 4], + use_cspsppf=True, + deepen_factor=deepen_factor, + widen_factor=widen_factor, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True)), + neck=dict( + type='YOLOv6RepBiPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[128, 256, 512, 1024], + out_channels=[128, 256, 512], + num_csp_blocks=12, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True), + ), + bbox_head=dict( + type='YOLOv6Head', + head_module=dict( + type='YOLOv6HeadModule', + num_classes=num_classes, + in_channels=[128, 256, 512], + widen_factor=widen_factor, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='SiLU', inplace=True), + featmap_strides=[8, 16, 32]), + loss_bbox=dict( + type='IoULoss', + iou_mode='giou', + bbox_format='xyxy', + reduction='mean', + loss_weight=2.5, + return_iou=False)), + train_cfg=dict( + initial_epoch=4, + initial_assigner=dict( + type='BatchATSSAssigner', + num_classes=num_classes, + topk=9, + iou_calculator=dict(type='mmdet.BboxOverlaps2D')), + assigner=dict( + type='BatchTaskAlignedAssigner', + num_classes=num_classes, + topk=13, + alpha=1, + beta=6), + ), + test_cfg=dict( + multi_label=True, + nms_pre=30000, + score_thr=0.001, + nms=dict(type='nms', iou_threshold=0.65), + max_per_img=300)) + +# The training pipeline of YOLOv6 is basically the same as YOLOv5. +# The difference is that Mosaic and RandomAffine will be closed in the last 15 epochs. # noqa +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.1, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + max_shear_degree=0.0), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_translate_ratio=0.1, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_shear_degree=0.0, + ), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + collate_fn=dict(type='yolov5_collate'), + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +# Optimizer and learning rate scheduler of YOLOv6 are basically the same as YOLOv5. # noqa +# The difference is that the scheduler_type of YOLOv6 is cosine. +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.937, + weight_decay=weight_decay, + nesterov=True, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOv5OptimizerConstructor') + +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='cosine', + lr_factor=lr_factor, + max_epochs=max_epochs), + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + max_keep_ckpts=max_keep_ckpts, + save_best='auto')) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - num_last_epochs, + switch_pipeline=train_pipeline_stage2) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_epoch_intervals, + dynamic_intervals=[(max_epochs - num_last_epochs, 1)]) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_t_syncbn_fast_8xb32-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_t_syncbn_fast_8xb32-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..d088b6b6629345f6f086f67373206b6d6f9b7e31 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov6/yolov6_v3_t_syncbn_fast_8xb32-300e_coco.py @@ -0,0 +1,17 @@ +_base_ = './yolov6_v3_s_syncbn_fast_8xb32-300e_coco.py' + +# ======================= Possible modified parameters ======================= +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.375 + +# ============================== Unmodified in most cases =================== +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict( + type='YOLOv6Head', + head_module=dict(widen_factor=widen_factor), + loss_bbox=dict(iou_mode='siou'))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f8f87f8358e25b7c8004aabfe7229d7941b6919a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/README.md @@ -0,0 +1,50 @@ +# YOLOv7 + +> [YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors](https://arxiv.org/abs/2207.02696) + + + +## Abstract + +YOLOv7 surpasses all known object detectors in both speed and accuracy in the range from 5 FPS to 160 FPS and has the highest accuracy 56.8% AP among all known real-time object detectors with 30 FPS or higher on GPU V100. YOLOv7-E6 object detector (56 FPS V100, 55.9% AP) outperforms both transformer-based detector SWIN-L Cascade-Mask R-CNN (9.2 FPS A100, 53.9% AP) by 509% in speed and 2% in accuracy, and convolutional-based detector ConvNeXt-XL Cascade-Mask R-CNN (8.6 FPS A100, 55.2% AP) by 551% in speed and 0.7% AP in accuracy, as well as YOLOv7 outperforms: YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5, DETR, Deformable DETR, DINO-5scale-R50, ViT-Adapter-B and many other object detectors in speed and accuracy. Moreover, we train YOLOv7 only on MS COCO dataset from scratch without using any other datasets or pre-trained weights. Source code is released in [this https URL](https://github.com/WongKinYiu/yolov7). + +
+ +
+ +
+YOLOv7-l +YOLOv7-l-P5 model structure +
+ +## Results and models + +### COCO + +| Backbone | Arch | Size | SyncBN | AMP | Mem (GB) | Box AP | Config | Download | +| :---------: | :--: | :--: | :----: | :-: | :------: | :----: | :----------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOv7-tiny | P5 | 640 | Yes | Yes | 2.7 | 37.5 | [config](./yolov7_tiny_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco/yolov7_tiny_syncbn_fast_8x16b-300e_coco_20221126_102719-0ee5bbdf.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco/yolov7_tiny_syncbn_fast_8x16b-300e_coco_20221126_102719.log.json) | +| YOLOv7-l | P5 | 640 | Yes | Yes | 10.3 | 50.9 | [config](./yolov7_l_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco/yolov7_l_syncbn_fast_8x16b-300e_coco_20221123_023601-8113c0eb.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco/yolov7_l_syncbn_fast_8x16b-300e_coco_20221123_023601.log.json) | +| YOLOv7-x | P5 | 640 | Yes | Yes | 13.7 | 52.8 | [config](./yolov7_x_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco/yolov7_x_syncbn_fast_8x16b-300e_coco_20221124_215331-ef949a68.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco/yolov7_x_syncbn_fast_8x16b-300e_coco_20221124_215331.log.json) | +| YOLOv7-w | P6 | 1280 | Yes | Yes | 27.0 | 54.1 | [config](./yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco/yolov7_w-p6_syncbn_fast_8x16b-300e_coco_20221123_053031-a68ef9d2.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco/yolov7_w-p6_syncbn_fast_8x16b-300e_coco_20221123_053031.log.json) | +| YOLOv7-e | P6 | 1280 | Yes | Yes | 42.5 | 55.1 | [config](./yolov7_e-p6_syncbn_fast_8x16b-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco/yolov7_e-p6_syncbn_fast_8x16b-300e_coco_20221126_102636-34425033.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco/yolov7_e-p6_syncbn_fast_8x16b-300e_coco_20221126_102636.log.json) | + +**Note**: +In the official YOLOv7 code, the `random_perspective` data augmentation in COCO object detection task training uses mask annotation information, which leads to higher performance. Object detection should not use mask annotation, so only box annotation information is used in `MMYOLO`. We will use the mask annotation information in the instance segmentation task. + +1. The performance is unstable and may fluctuate by about 0.3 mAP. The performance shown above is the best model. +2. If users need the weight of `YOLOv7-e2e`, they can train according to the configs provided by us, or convert the official weight according to the [converter script](https://github.com/open-mmlab/mmyolo/blob/main/tools/model_converters/yolov7_to_mmyolo.py). +3. `fast` means that `YOLOv5DetDataPreprocessor` and `yolov5_collate` are used for data preprocessing, which is faster for training, but less flexible for multitasking. Recommended to use fast version config if you only care about object detection. +4. `SyncBN` means use SyncBN, `AMP` indicates training with mixed precision. +5. We use 8x A100 for training, and the single-GPU batch size is 16. This is different from the official code. + +## Citation + +```latex +@article{wang2022yolov7, + title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors}, + author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark}, + journal={arXiv preprint arXiv:2207.02696}, + year={2022} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..067ec6b45afefa2ae444b0343ad327b94f1507d2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/metafile.yml @@ -0,0 +1,83 @@ +Collections: + - Name: YOLOv7 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - AMP + - Synchronize BN + Training Resources: 8x A100 GPUs + Architecture: + - EELAN + - PAFPN + - RepVGG + Paper: + URL: https://arxiv.org/abs/2207.02696 + Title: 'YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors' + README: configs/yolov7/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.0.1/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.0.1 + +Models: + - Name: yolov7_tiny_syncbn_fast_8x16b-300e_coco + In Collection: YOLOv7 + Config: configs/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco.py + Metadata: + Training Memory (GB): 2.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.5 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco/yolov7_tiny_syncbn_fast_8x16b-300e_coco_20221126_102719-0ee5bbdf.pth + - Name: yolov7_l_syncbn_fast_8x16b-300e_coco + In Collection: YOLOv7 + Config: configs/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco.py + Metadata: + Training Memory (GB): 10.3 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.9 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco/yolov7_l_syncbn_fast_8x16b-300e_coco_20221123_023601-8113c0eb.pth + - Name: yolov7_x_syncbn_fast_8x16b-300e_coco + In Collection: YOLOv7 + Config: configs/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco.py + Metadata: + Training Memory (GB): 13.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.8 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco/yolov7_x_syncbn_fast_8x16b-300e_coco_20221124_215331-ef949a68.pth + - Name: yolov7_w-p6_syncbn_fast_8x16b-300e_coco + In Collection: YOLOv7 + Config: configs/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py + Metadata: + Training Memory (GB): 27.0 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 54.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco/yolov7_w-p6_syncbn_fast_8x16b-300e_coco_20221123_053031-a68ef9d2.pth + - Name: yolov7_e-p6_syncbn_fast_8x16b-300e_coco + In Collection: YOLOv7 + Config: configs/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco.py + Metadata: + Training Memory (GB): 42.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 55.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco/yolov7_e-p6_syncbn_fast_8x16b-300e_coco_20221126_102636-34425033.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_d-p6_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_d-p6_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..a68715264d59c16ef2b31010ede44310d97a3a7e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_d-p6_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py' + +model = dict( + backbone=dict(arch='D'), + neck=dict( + use_maxpool_in_downsample=True, + use_in_channels_in_downsample=True, + block_cfg=dict( + type='ELANBlock', + middle_ratio=0.4, + block_ratio=0.2, + num_blocks=6, + num_convs_in_block=1), + in_channels=[384, 768, 1152, 1536], + out_channels=[192, 384, 576, 768]), + bbox_head=dict( + head_module=dict( + in_channels=[192, 384, 576, 768], + main_out_channels=[384, 768, 1152, 1536], + aux_out_channels=[384, 768, 1152, 1536], + ))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..3d1463dc487e05eabfd3f586a28262017a9dc566 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_e-p6_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,19 @@ +_base_ = './yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py' + +model = dict( + backbone=dict(arch='E'), + neck=dict( + use_maxpool_in_downsample=True, + use_in_channels_in_downsample=True, + block_cfg=dict( + type='ELANBlock', + middle_ratio=0.4, + block_ratio=0.2, + num_blocks=6, + num_convs_in_block=1), + in_channels=[320, 640, 960, 1280], + out_channels=[160, 320, 480, 640]), + bbox_head=dict( + head_module=dict( + in_channels=[160, 320, 480, 640], + main_out_channels=[320, 640, 960, 1280]))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_e2e-p6_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_e2e-p6_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..6af81051b72977410d5b51cf7a02a476d55ceb24 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_e2e-p6_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,20 @@ +_base_ = './yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py' + +model = dict( + backbone=dict(arch='E2E'), + neck=dict( + use_maxpool_in_downsample=True, + use_in_channels_in_downsample=True, + block_cfg=dict( + type='EELANBlock', + num_elan_block=2, + middle_ratio=0.4, + block_ratio=0.2, + num_blocks=6, + num_convs_in_block=1), + in_channels=[320, 640, 960, 1280], + out_channels=[160, 320, 480, 640]), + bbox_head=dict( + head_module=dict( + in_channels=[160, 320, 480, 640], + main_out_channels=[320, 640, 960, 1280]))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..e8a756c27e5366e3a83658132b0e330a5f68ad22 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_l_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,324 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 16 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----model related----- +# Basic size of multi-scale prior box +anchors = [ + [(12, 16), (19, 36), (40, 28)], # P3/8 + [(36, 75), (76, 55), (72, 146)], # P4/16 + [(142, 110), (192, 243), (459, 401)] # P5/32 +] +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 8xb16=128 bs +base_lr = 0.01 +max_epochs = 300 # Maximum training epochs + +num_epoch_stage2 = 30 # The last 30 epochs switch evaluation interval +val_interval_stage2 = 1 # Evaluation interval + +model_test_cfg = dict( + # The config of multi-label for multi-class prediction. + multi_label=True, + # The number of boxes before NMS. + nms_pre=30000, + score_thr=0.001, # Threshold to filter out boxes. + nms=dict(type='nms', iou_threshold=0.65), # NMS type and threshold + max_per_img=300) # Max number of detections of each image + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# Config of batch shapes. Only on val. +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + # The image scale of padding should be divided by pad_size_divisor + size_divisor=32, + # Additional paddings for pixel scale + extra_pad_ratio=0.5) + +# -----model related----- +strides = [8, 16, 32] # Strides of multi-scale prior box +num_det_layers = 3 # The number of model output scales +norm_cfg = dict(type='BN', momentum=0.03, eps=0.001) + +# Data augmentation +max_translate_ratio = 0.2 # YOLOv5RandomAffine +scaling_ratio_range = (0.1, 2.0) # YOLOv5RandomAffine +mixup_prob = 0.15 # YOLOv5MixUp +randchoice_mosaic_prob = [0.8, 0.2] +mixup_alpha = 8.0 # YOLOv5MixUp +mixup_beta = 8.0 # YOLOv5MixUp + +# -----train val related----- +loss_cls_weight = 0.3 +loss_bbox_weight = 0.05 +loss_obj_weight = 0.7 +# BatchYOLOv7Assigner params +simota_candidate_topk = 10 +simota_iou_weight = 3.0 +simota_cls_weight = 1.0 +prior_match_thr = 4. # Priori box matching threshold +obj_level_weights = [4., 1., + 0.4] # The obj loss weights of the three output layers + +lr_factor = 0.1 # Learning rate scaling factor +weight_decay = 0.0005 +save_epoch_intervals = 1 # Save model checkpoint and validation intervals +max_keep_ckpts = 3 # The maximum checkpoints to keep. + +# Single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='YOLOv7Backbone', + arch='L', + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + type='YOLOv7PAFPN', + block_cfg=dict( + type='ELANBlock', + middle_ratio=0.5, + block_ratio=0.25, + num_blocks=4, + num_convs_in_block=1), + upsample_feats_cat_first=False, + in_channels=[512, 1024, 1024], + # The real output channel will be multiplied by 2 + out_channels=[128, 256, 512], + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='YOLOv7Head', + head_module=dict( + type='YOLOv7HeadModule', + num_classes=num_classes, + in_channels=[256, 512, 1024], + featmap_strides=strides, + num_base_priors=3), + prior_generator=dict( + type='mmdet.YOLOAnchorGenerator', + base_sizes=anchors, + strides=strides), + # scaled based on number of detection layers + loss_cls=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_bbox=dict( + type='IoULoss', + iou_mode='ciou', + bbox_format='xywh', + reduction='mean', + loss_weight=loss_bbox_weight * (3 / num_det_layers), + return_iou=True), + loss_obj=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)), + prior_match_thr=prior_match_thr, + obj_level_weights=obj_level_weights, + # BatchYOLOv7Assigner params + simota_candidate_topk=simota_candidate_topk, + simota_iou_weight=simota_iou_weight, + simota_cls_weight=simota_cls_weight), + test_cfg=model_test_cfg) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +mosiac4_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_translate_ratio=max_translate_ratio, # note + scaling_ratio_range=scaling_ratio_range, # note + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), +] + +mosiac9_pipeline = [ + dict( + type='Mosaic9', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_translate_ratio=max_translate_ratio, # note + scaling_ratio_range=scaling_ratio_range, # note + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), +] + +randchoice_mosaic_pipeline = dict( + type='RandomChoice', + transforms=[mosiac4_pipeline, mosiac9_pipeline], + prob=randchoice_mosaic_prob) + +train_pipeline = [ + *pre_transform, + randchoice_mosaic_pipeline, + dict( + type='YOLOv5MixUp', + alpha=mixup_alpha, # note + beta=mixup_beta, # note + prob=mixup_prob, + pre_transform=[*pre_transform, randchoice_mosaic_pipeline]), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + collate_fn=dict(type='yolov5_collate'), # FASTER + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +param_scheduler = None +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.937, + weight_decay=weight_decay, + nesterov=True, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOv7OptimWrapperConstructor') + +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='cosine', + lr_factor=lr_factor, # note + max_epochs=max_epochs), + checkpoint=dict( + type='CheckpointHook', + save_param_scheduler=False, + interval=save_epoch_intervals, + save_best='auto', + max_keep_ckpts=max_keep_ckpts)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), # Can be accelerated + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_epoch_intervals, + dynamic_intervals=[(max_epochs - num_epoch_stage2, val_interval_stage2)]) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_tiny_fast_1xb12-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_tiny_fast_1xb12-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..eb0446760eeb39951ad2bf6a8cbb1fe3cc19870a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_tiny_fast_1xb12-40e_cat.py @@ -0,0 +1,56 @@ +_base_ = 'yolov7_tiny_syncbn_fast_8x16b-300e_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +anchors = [ + [(68, 69), (154, 91), (143, 162)], # P3/8 + [(242, 160), (189, 287), (391, 207)], # P4/16 + [(353, 337), (539, 341), (443, 432)] # P5/32 +] + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 4 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco/yolov7_tiny_syncbn_fast_8x16b-300e_coco_20221126_102719-0ee5bbdf.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict( + head_module=dict(num_classes=num_classes), + prior_generator=dict(base_sizes=anchors))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +_base_.optim_wrapper.optimizer.batch_size_per_gpu = train_batch_size_per_gpu + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + # The warmup_mim_iter parameter is critical. + # The default value is 1000 which is not suitable for cat datasets. + param_scheduler=dict(max_epochs=max_epochs, warmup_mim_iter=10), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b9e9f10e2926a840d2af7a9e27b0e2047710343d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_tiny_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,98 @@ +_base_ = './yolov7_l_syncbn_fast_8x16b-300e_coco.py' + +# ========================modified parameters======================== + +# -----model related----- +# Data augmentation +max_translate_ratio = 0.1 # YOLOv5RandomAffine +scaling_ratio_range = (0.5, 1.6) # YOLOv5RandomAffine +mixup_prob = 0.05 # YOLOv5MixUp +randchoice_mosaic_prob = [0.8, 0.2] +mixup_alpha = 8.0 # YOLOv5MixUp +mixup_beta = 8.0 # YOLOv5MixUp + +# -----train val related----- +loss_cls_weight = 0.5 +loss_obj_weight = 1.0 + +lr_factor = 0.01 # Learning rate scaling factor +# ===============================Unmodified in most cases==================== +num_classes = _base_.num_classes +num_det_layers = _base_.num_det_layers +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform +model = dict( + backbone=dict( + arch='Tiny', act_cfg=dict(type='LeakyReLU', negative_slope=0.1)), + neck=dict( + is_tiny_version=True, + in_channels=[128, 256, 512], + out_channels=[64, 128, 256], + block_cfg=dict( + _delete_=True, type='TinyDownSampleBlock', middle_ratio=0.25), + act_cfg=dict(type='LeakyReLU', negative_slope=0.1), + use_repconv_outs=False), + bbox_head=dict( + head_module=dict(in_channels=[128, 256, 512]), + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)))) + +mosiac4_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_translate_ratio=max_translate_ratio, # change + scaling_ratio_range=scaling_ratio_range, # change + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), +] + +mosiac9_pipeline = [ + dict( + type='Mosaic9', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_translate_ratio=max_translate_ratio, # change + scaling_ratio_range=scaling_ratio_range, # change + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), +] + +randchoice_mosaic_pipeline = dict( + type='RandomChoice', + transforms=[mosiac4_pipeline, mosiac9_pipeline], + prob=randchoice_mosaic_prob) + +train_pipeline = [ + *pre_transform, + randchoice_mosaic_pipeline, + dict( + type='YOLOv5MixUp', + alpha=mixup_alpha, + beta=mixup_beta, + prob=mixup_prob, # change + pre_transform=[*pre_transform, randchoice_mosaic_pipeline]), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..9758b871785050ef41303082aab745a6568e373b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_w-p6_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,182 @@ +_base_ = './yolov7_l_syncbn_fast_8x16b-300e_coco.py' + +# ========================modified parameters======================== +# -----data related----- +img_scale = (1280, 1280) # height, width +num_classes = 80 # Number of classes for classification +# Config of batch shapes. Only on val +# It means not used if batch_shapes_cfg is None. +batch_shapes_cfg = dict( + img_size=img_scale[ + 0], # The image scale of padding should be divided by pad_size_divisor + size_divisor=64) # Additional paddings for pixel scale +tta_img_scales = [(1280, 1280), (1024, 1024), (1536, 1536)] + +# -----model related----- +# Basic size of multi-scale prior box +anchors = [ + [(19, 27), (44, 40), (38, 94)], # P3/8 + [(96, 68), (86, 152), (180, 137)], # P4/16 + [(140, 301), (303, 264), (238, 542)], # P5/32 + [(436, 615), (739, 380), (925, 792)] # P6/64 +] +strides = [8, 16, 32, 64] # Strides of multi-scale prior box +num_det_layers = 4 # # The number of model output scales +norm_cfg = dict(type='BN', momentum=0.03, eps=0.001) + +# Data augmentation +max_translate_ratio = 0.2 # YOLOv5RandomAffine +scaling_ratio_range = (0.1, 2.0) # YOLOv5RandomAffine +mixup_prob = 0.15 # YOLOv5MixUp +randchoice_mosaic_prob = [0.8, 0.2] +mixup_alpha = 8.0 # YOLOv5MixUp +mixup_beta = 8.0 # YOLOv5MixUp + +# -----train val related----- +loss_cls_weight = 0.3 +loss_bbox_weight = 0.05 +loss_obj_weight = 0.7 +obj_level_weights = [4.0, 1.0, 0.25, 0.06] +simota_candidate_topk = 20 + +# The only difference between P6 and P5 in terms of +# hyperparameters is lr_factor +lr_factor = 0.2 + +# ===============================Unmodified in most cases==================== +pre_transform = _base_.pre_transform + +model = dict( + backbone=dict(arch='W', out_indices=(2, 3, 4, 5)), + neck=dict( + in_channels=[256, 512, 768, 1024], + out_channels=[128, 256, 384, 512], + use_maxpool_in_downsample=False, + use_repconv_outs=False), + bbox_head=dict( + head_module=dict( + type='YOLOv7p6HeadModule', + in_channels=[128, 256, 384, 512], + featmap_strides=strides, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + prior_generator=dict(base_sizes=anchors, strides=strides), + simota_candidate_topk=simota_candidate_topk, # note + # scaled based on number of detection layers + loss_cls=dict(loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), + loss_bbox=dict(loss_weight=loss_bbox_weight * (3 / num_det_layers)), + loss_obj=dict(loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)), + obj_level_weights=obj_level_weights)) + +mosiac4_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_translate_ratio=max_translate_ratio, # note + scaling_ratio_range=scaling_ratio_range, # note + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), +] + +mosiac9_pipeline = [ + dict( + type='Mosaic9', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_translate_ratio=max_translate_ratio, # note + scaling_ratio_range=scaling_ratio_range, # note + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), +] + +randchoice_mosaic_pipeline = dict( + type='RandomChoice', + transforms=[mosiac4_pipeline, mosiac9_pipeline], + prob=randchoice_mosaic_prob) + +train_pipeline = [ + *pre_transform, + randchoice_mosaic_pipeline, + dict( + type='YOLOv5MixUp', + alpha=mixup_alpha, # note + beta=mixup_beta, # note + prob=mixup_prob, + pre_transform=[*pre_transform, randchoice_mosaic_pipeline]), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=batch_shapes_cfg)) +test_dataloader = val_dataloader + +default_hooks = dict(param_scheduler=dict(lr_factor=lr_factor)) + +# Config for Test Time Augmentation. (TTA) +_multiscale_resize_transforms = [ + dict( + type='Compose', + transforms=[ + dict(type='YOLOv5KeepRatioResize', scale=s), + dict( + type='LetterResize', + scale=s, + allow_scale_up=False, + pad_val=dict(img=114)) + ]) for s in tta_img_scales +] + +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='TestTimeAug', + transforms=[ + _multiscale_resize_transforms, + [ + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'flip', + 'flip_direction')) + ] + ]) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..9929705962c918392af12dd0a8275321f89fd361 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov7/yolov7_x_syncbn_fast_8x16b-300e_coco.py @@ -0,0 +1,15 @@ +_base_ = './yolov7_l_syncbn_fast_8x16b-300e_coco.py' + +model = dict( + backbone=dict(arch='X'), + neck=dict( + in_channels=[640, 1280, 1280], + out_channels=[160, 320, 640], + block_cfg=dict( + type='ELANBlock', + middle_ratio=0.4, + block_ratio=0.4, + num_blocks=3, + num_convs_in_block=2), + use_repconv_outs=False), + bbox_head=dict(head_module=dict(in_channels=[320, 640, 1280]))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/README.md new file mode 100644 index 0000000000000000000000000000000000000000..766aa99163c97bff5206724febd41c3e484faa55 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/README.md @@ -0,0 +1,45 @@ +# YOLOv8 + + + +## Abstract + +Ultralytics YOLOv8, developed by Ultralytics, is a cutting-edge, state-of-the-art (SOTA) model that builds upon the success of previous YOLO versions and introduces new features and improvements to further boost performance and flexibility. YOLOv8 is designed to be fast, accurate, and easy to use, making it an excellent choice for a wide range of object detection, image segmentation and image classification tasks. + +
+ +YOLOv8 performance +
+ +
+ +YOLOv8-P5 model structure +
+ +## Results and models + +### COCO + +| Backbone | Arch | size | Mask Refine | SyncBN | AMP | Mem (GB) | box AP | TTA box AP | Config | Download | +| :------: | :--: | :--: | :---------: | :----: | :-: | :------: | :---------: | :--------: | :-------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOv8-n | P5 | 640 | No | Yes | Yes | 2.8 | 37.2 | | [config](./yolov8_n_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco/yolov8_n_syncbn_fast_8xb16-500e_coco_20230114_131804-88c11cdb.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco/yolov8_n_syncbn_fast_8xb16-500e_coco_20230114_131804.log.json) | +| YOLOv8-n | P5 | 640 | Yes | Yes | Yes | 2.5 | 37.4 (+0.2) | 39.9 | [config](./yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_101206-b975b1cd.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_101206.log.json) | +| YOLOv8-s | P5 | 640 | No | Yes | Yes | 4.0 | 44.2 | | [config](./yolov8_s_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco/yolov8_s_syncbn_fast_8xb16-500e_coco_20230117_180101-5aa5f0f1.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco/yolov8_s_syncbn_fast_8xb16-500e_coco_20230117_180101.log.json) | +| YOLOv8-s | P5 | 640 | Yes | Yes | Yes | 4.0 | 45.1 (+0.9) | 46.8 | [config](./yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_095938-ce3c1b3f.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_095938.log.json) | +| YOLOv8-m | P5 | 640 | No | Yes | Yes | 7.2 | 49.8 | | [config](./yolov8_m_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco/yolov8_m_syncbn_fast_8xb16-500e_coco_20230115_192200-c22e560a.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco/yolov8_m_syncbn_fast_8xb16-500e_coco_20230115_192200.log.json) | +| YOLOv8-m | P5 | 640 | Yes | Yes | Yes | 7.0 | 50.6 (+0.8) | 52.3 | [config](./yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_223400-f40abfcd.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_223400.log.json) | +| YOLOv8-l | P5 | 640 | No | Yes | Yes | 9.8 | 52.1 | | [config](./yolov8_l_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco/yolov8_l_syncbn_fast_8xb16-500e_coco_20230217_182526-189611b6.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco/yolov8_l_syncbn_fast_8xb16-500e_coco_20230217_182526.log.json) | +| YOLOv8-l | P5 | 640 | Yes | Yes | Yes | 9.1 | 53.0 (+0.9) | 54.4 | [config](./yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco_20230217_120100-5881dec4.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco_20230217_120100.log.json) | +| YOLOv8-x | P5 | 640 | No | Yes | Yes | 12.2 | 52.7 | | [config](./yolov8_x_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco/yolov8_x_syncbn_fast_8xb16-500e_coco_20230218_023338-5674673c.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco/yolov8_x_syncbn_fast_8xb16-500e_coco_20230218_023338.log.json) | +| YOLOv8-x | P5 | 640 | Yes | Yes | Yes | 12.4 | 54.0 (+1.3) | 55.0 | [config](./yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco_20230217_120411-079ca8d1.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco_20230217_120411.log.json) | + +**Note** + +1. We use 8x A100 for training, and the single-GPU batch size is 16. This is different from the official code, but has no effect on performance. +2. The performance is unstable and may fluctuate by about 0.3 mAP and the highest performance weight in `COCO` training in `YOLOv8` may not be the last epoch. The performance shown above is the best model. +3. We provide [scripts](https://github.com/open-mmlab/mmyolo/tree/dev/tools/model_converters/yolov8_to_mmyolo.py) to convert official weights to MMYOLO. +4. `SyncBN` means using SyncBN, `AMP` indicates training with mixed precision. +5. The performance of `Mask Refine` training is for the weight performance officially released by YOLOv8. `Mask Refine` means refining bbox by mask while loading annotations and transforming after `YOLOv5RandomAffine`, and the L and X models use `Copy Paste`. +6. `TTA` means that Test Time Augmentation. It's perform 3 multi-scaling transformations on the image, followed by 2 flipping transformations (flipping and not flipping). You only need to specify `--tta` when testing to enable. see [TTA](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/common_usage/tta.md) for details. + +## Citation diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..33cd22bc69114f39c4b2a1fcaeabf5228534bb68 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/metafile.yml @@ -0,0 +1,140 @@ +Collections: + - Name: YOLOv8 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - AMP + - Synchronize BN + Training Resources: 8x A100 GPUs + Architecture: + - CSPDarkNet + - PAFPN + - Decoupled Head + README: configs/yolov8/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.0.1/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.0.1 + +Models: + - Name: yolov8_n_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 2.8 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.2 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco/yolov8_n_syncbn_fast_8xb16-500e_coco_20230114_131804-88c11cdb.pth + - Name: yolov8_s_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 4.0 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.2 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco/yolov8_s_syncbn_fast_8xb16-500e_coco_20230117_180101-5aa5f0f1.pth + - Name: yolov8_m_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 7.2 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.8 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco/yolov8_m_syncbn_fast_8xb16-500e_coco_20230115_192200-c22e560a.pth + - Name: yolov8_l_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 9.8 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco/yolov8_l_syncbn_fast_8xb16-500e_coco_20230217_182526-189611b6.pth + - Name: yolov8_x_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 12.2 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco/yolov8_x_syncbn_fast_8xb16-500e_coco_20230218_023338-5674673c.pth + - Name: yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 2.5 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_101206-b975b1cd.pth + - Name: yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 4.0 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_095938-ce3c1b3f.pth + - Name: yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 7.0 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.6 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco_20230216_223400-f40abfcd.pth + - Name: yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 9.1 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 53.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco_20230217_120100-5881dec4.pth + - Name: yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco + In Collection: YOLOv8 + Config: configs/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py + Metadata: + Training Memory (GB): 12.4 + Epochs: 500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 54.0 + Weights: https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco_20230217_120411-079ca8d1.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..e25b6bcb63d1bad084f7c2175a6983dadb591fc4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,65 @@ +_base_ = './yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py' + +# This config use refining bbox and `YOLOv5CopyPaste`. +# Refining bbox means refining bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 1.00 +widen_factor = 1.00 +last_stage_out_channels = 512 + +mixup_prob = 0.15 +copypaste_prob = 0.3 + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform +last_transform = _base_.last_transform +affine_scale = _base_.affine_scale + +model = dict( + backbone=dict( + last_stage_out_channels=last_stage_out_channels, + deepen_factor=deepen_factor, + widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels], + out_channels=[256, 512, last_stage_out_channels]), + bbox_head=dict( + head_module=dict( + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels]))) + +mosaic_affine_transform = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] + +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..bea8b2d56fecd46beddd0370732e8b83309528e5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_l_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,39 @@ +_base_ = './yolov8_m_syncbn_fast_8xb16-500e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 1.00 +widen_factor = 1.00 +last_stage_out_channels = 512 + +mixup_prob = 0.15 + +# =======================Unmodified in most cases================== +pre_transform = _base_.pre_transform +mosaic_affine_transform = _base_.mosaic_affine_transform +last_transform = _base_.last_transform + +model = dict( + backbone=dict( + last_stage_out_channels=last_stage_out_channels, + deepen_factor=deepen_factor, + widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels], + out_channels=[256, 512, last_stage_out_channels]), + bbox_head=dict( + head_module=dict( + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels]))) + +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..2884daeb436e321c2c256687e0f063780d680f37 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_m_mask-refine_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,85 @@ +_base_ = './yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py' + +# This config use refining bbox and `YOLOv5CopyPaste`. +# Refining bbox means refining bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 +last_stage_out_channels = 768 + +affine_scale = 0.9 +mixup_prob = 0.1 +copypaste_prob = 0.1 + +# ===============================Unmodified in most cases==================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform +last_transform = _base_.last_transform + +model = dict( + backbone=dict( + last_stage_out_channels=last_stage_out_channels, + deepen_factor=deepen_factor, + widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels], + out_channels=[256, 512, last_stage_out_channels]), + bbox_head=dict( + head_module=dict( + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels]))) + +mosaic_affine_transform = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='YOLOv5CopyPaste', prob=copypaste_prob), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100., + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine) +] + +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=_base_.min_area_ratio, + use_mask_refine=_base_.use_mask2refine), *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +_base_.custom_hooks[1].switch_pipeline = train_pipeline_stage2 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..840d32ccff78db31d9945bfe32531c1970845ee7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_m_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,76 @@ +_base_ = './yolov8_s_syncbn_fast_8xb16-500e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 +last_stage_out_channels = 768 + +affine_scale = 0.9 +mixup_prob = 0.1 + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform +last_transform = _base_.last_transform + +model = dict( + backbone=dict( + last_stage_out_channels=last_stage_out_channels, + deepen_factor=deepen_factor, + widen_factor=widen_factor), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels], + out_channels=[256, 512, last_stage_out_channels]), + bbox_head=dict( + head_module=dict( + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels]))) + +mosaic_affine_transform = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + max_aspect_ratio=100, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +# enable mixup +train_pipeline = [ + *pre_transform, *mosaic_affine_transform, + dict( + type='YOLOv5MixUp', + prob=mixup_prob, + pre_transform=[*pre_transform, *mosaic_affine_transform]), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=100, + border_val=(114, 114, 114)), *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +_base_.custom_hooks[1].switch_pipeline = train_pipeline_stage2 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..50d3774267fd89b747574f72b34e6d7d2237c5ef --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_n_mask-refine_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,12 @@ +_base_ = './yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +deepen_factor = 0.33 +widen_factor = 0.25 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..5833df3a157151bca2d2ce29380962e43f1ec876 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_n_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,9 @@ +_base_ = './yolov8_s_syncbn_fast_8xb16-500e_coco.py' + +deepen_factor = 0.33 +widen_factor = 0.25 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_fast_1xb12-40e_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_fast_1xb12-40e_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..e54bff03358c4138ea175187f6617735e80f185e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_fast_1xb12-40e_cat.py @@ -0,0 +1,52 @@ +_base_ = 'yolov8_s_syncbn_fast_8xb16-500e_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +close_mosaic_epochs = 5 + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 4 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco/yolov8_s_syncbn_fast_8xb16-500e_coco_20230117_180101-5aa5f0f1.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict(head_module=dict(num_classes=num_classes)), + train_cfg=dict(assigner=dict(num_classes=num_classes))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +_base_.optim_wrapper.optimizer.batch_size_per_gpu = train_batch_size_per_gpu +_base_.custom_hooks[1].switch_epoch = max_epochs - close_mosaic_epochs + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + # The warmup_mim_iter parameter is critical. + # The default value is 1000 which is not suitable for cat datasets. + param_scheduler=dict(max_epochs=max_epochs, warmup_mim_iter=10), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..769a698e4b52886797e08169cdc6da8eedea204d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_mask-refine_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,83 @@ +_base_ = './yolov8_s_syncbn_fast_8xb16-500e_coco.py' + +# This config will refine bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +# ========================modified parameters====================== +use_mask2refine = True +min_area_ratio = 0.01 # YOLOv5RandomAffine + +# ===============================Unmodified in most cases==================== +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + mask2bbox=use_mask2refine) +] + +last_transform = [ + # Delete gt_masks to avoid more computation + dict(type='RemoveDataElement', keys=['gt_masks']), + dict( + type='mmdet.Albu', + transforms=_base_.albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=_base_.img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + # img_scale is (width, height) + border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2), + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=_base_.img_scale), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - _base_.affine_scale, 1 + _base_.affine_scale), + max_aspect_ratio=_base_.max_aspect_ratio, + border_val=(114, 114, 114), + min_area_ratio=min_area_ratio, + use_mask_refine=use_mask2refine), *last_transform +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +_base_.custom_hooks[1].switch_pipeline = train_pipeline_stage2 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..7e4127efbfd549803d8794b0bdf9fbcc9565e55c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,334 @@ +_base_ = ['../_base_/default_runtime.py', '../_base_/det_p5_tta.py'] + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# Path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# Path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of val image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 16 +# Worker to pre-fetch data for each single GPU during training +train_num_workers = 8 +# persistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 8xb16=64 bs +base_lr = 0.01 +max_epochs = 500 # Maximum training epochs +# Disable mosaic augmentation for final 10 epochs (stage 2) +close_mosaic_epochs = 10 + +model_test_cfg = dict( + # The config of multi-label for multi-class prediction. + multi_label=True, + # The number of boxes before NMS + nms_pre=30000, + score_thr=0.001, # Threshold to filter out boxes. + nms=dict(type='nms', iou_threshold=0.7), # NMS type and threshold + max_per_img=300) # Max number of detections of each image + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# Config of batch shapes. Only on val. +# We tested YOLOv8-m will get 0.02 higher than not using it. +batch_shapes_cfg = None +# You can turn on `batch_shapes_cfg` by uncommenting the following lines. +# batch_shapes_cfg = dict( +# type='BatchShapePolicy', +# batch_size=val_batch_size_per_gpu, +# img_size=img_scale[0], +# # The image scale of padding should be divided by pad_size_divisor +# size_divisor=32, +# # Additional paddings for pixel scale +# extra_pad_ratio=0.5) + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.5 +# Strides of multi-scale prior box +strides = [8, 16, 32] +# The output channel of the last stage +last_stage_out_channels = 1024 +num_det_layers = 3 # The number of model output scales +norm_cfg = dict(type='BN', momentum=0.03, eps=0.001) # Normalization config + +# -----train val related----- +affine_scale = 0.5 # YOLOv5RandomAffine scaling ratio +# YOLOv5RandomAffine aspect ratio of width and height thres to filter bboxes +max_aspect_ratio = 100 +tal_topk = 10 # Number of bbox selected in each level +tal_alpha = 0.5 # A Hyper-parameter related to alignment_metrics +tal_beta = 6.0 # A Hyper-parameter related to alignment_metrics +# TODO: Automatically scale loss_weight based on number of detection layers +loss_cls_weight = 0.5 +loss_bbox_weight = 7.5 +# Since the dfloss is implemented differently in the official +# and mmdet, we're going to divide loss_weight by 4. +loss_dfl_weight = 1.5 / 4 +lr_factor = 0.01 # Learning rate scaling factor +weight_decay = 0.0005 +# Save model checkpoint and validation intervals in stage 1 +save_epoch_intervals = 10 +# validation intervals in stage 2 +val_interval_stage2 = 1 +# The maximum checkpoints to keep. +max_keep_ckpts = 2 +# Single-scale training is recommended to +# be turned on, which can speed up training. +env_cfg = dict(cudnn_benchmark=True) + +# ===============================Unmodified in most cases==================== +model = dict( + type='YOLODetector', + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + mean=[0., 0., 0.], + std=[255., 255., 255.], + bgr_to_rgb=True), + backbone=dict( + type='YOLOv8CSPDarknet', + arch='P5', + last_stage_out_channels=last_stage_out_channels, + deepen_factor=deepen_factor, + widen_factor=widen_factor, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + type='YOLOv8PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, last_stage_out_channels], + out_channels=[256, 512, last_stage_out_channels], + num_csp_blocks=3, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='YOLOv8Head', + head_module=dict( + type='YOLOv8HeadModule', + num_classes=num_classes, + in_channels=[256, 512, last_stage_out_channels], + widen_factor=widen_factor, + reg_max=16, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + featmap_strides=strides), + prior_generator=dict( + type='mmdet.MlvlPointGenerator', offset=0.5, strides=strides), + bbox_coder=dict(type='DistancePointBBoxCoder'), + # scaled based on number of detection layers + loss_cls=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='none', + loss_weight=loss_cls_weight), + loss_bbox=dict( + type='IoULoss', + iou_mode='ciou', + bbox_format='xyxy', + reduction='sum', + loss_weight=loss_bbox_weight, + return_iou=False), + loss_dfl=dict( + type='mmdet.DistributionFocalLoss', + reduction='mean', + loss_weight=loss_dfl_weight)), + train_cfg=dict( + assigner=dict( + type='BatchTaskAlignedAssigner', + num_classes=num_classes, + use_ciou=True, + topk=tal_topk, + alpha=tal_alpha, + beta=tal_beta, + eps=1e-9)), + test_cfg=model_test_cfg) + +albu_train_transforms = [ + dict(type='Blur', p=0.01), + dict(type='MedianBlur', p=0.01), + dict(type='ToGray', p=0.01), + dict(type='CLAHE', p=0.01) +] + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +last_transform = [ + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=max_aspect_ratio, + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)), + *last_transform +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=True, + pad_val=dict(img=114.0)), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + max_aspect_ratio=max_aspect_ratio, + border_val=(114, 114, 114)), *last_transform +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + collate_fn=dict(type='yolov5_collate'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file, + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) + +test_dataloader = val_dataloader + +param_scheduler = None +optim_wrapper = dict( + type='OptimWrapper', + clip_grad=dict(max_norm=10.0), + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.937, + weight_decay=weight_decay, + nesterov=True, + batch_size_per_gpu=train_batch_size_per_gpu), + constructor='YOLOv5OptimizerConstructor') + +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', + scheduler_type='linear', + lr_factor=lr_factor, + max_epochs=max_epochs), + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + save_best='auto', + max_keep_ckpts=max_keep_ckpts)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - close_mosaic_epochs, + switch_pipeline=train_pipeline_stage2) +] + +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') +test_evaluator = val_evaluator + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_epoch_intervals, + dynamic_intervals=[((max_epochs - close_mosaic_epochs), + val_interval_stage2)]) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8c27b9619d288f222ea0ce351f9e4578c31934a7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_x_mask-refine_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,13 @@ +_base_ = './yolov8_l_mask-refine_syncbn_fast_8xb16-500e_coco.py' + +# This config use refining bbox and `YOLOv5CopyPaste`. +# Refining bbox means refining bbox by mask while loading annotations and +# transforming after `YOLOv5RandomAffine` + +deepen_factor = 1.00 +widen_factor = 1.25 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..3d8e6653278db54745aa3a3a606bc63aa40328b7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolov8/yolov8_x_syncbn_fast_8xb16-500e_coco.py @@ -0,0 +1,9 @@ +_base_ = './yolov8_l_syncbn_fast_8xb16-500e_coco.py' + +deepen_factor = 1.00 +widen_factor = 1.25 + +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7d5dc683c1b2e912ee27c7492bf7f869c103bb15 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/README.md @@ -0,0 +1,86 @@ +# YOLOX + +> [YOLOX: Exceeding YOLO Series in 2021](https://arxiv.org/abs/2107.08430) + + + +## Abstract + +In this report, we present some experienced improvements to YOLO series, forming a new high-performance detector -- YOLOX. We switch the YOLO detector to an anchor-free manner and conduct other advanced detection techniques, i.e., a decoupled head and the leading label assignment strategy SimOTA to achieve state-of-the-art results across a large scale range of models: For YOLO-Nano with only 0.91M parameters and 1.08G FLOPs, we get 25.3% AP on COCO, surpassing NanoDet by 1.8% AP; for YOLOv3, one of the most widely used detectors in industry, we boost it to 47.3% AP on COCO, outperforming the current best practice by 3.0% AP; for YOLOX-L with roughly the same amount of parameters as YOLOv4-CSP, YOLOv5-L, we achieve 50.0% AP on COCO at a speed of 68.9 FPS on Tesla V100, exceeding YOLOv5-L by 1.8% AP. Further, we won the 1st Place on Streaming Perception Challenge (Workshop on Autonomous Driving at CVPR 2021) using a single YOLOX-L model. We hope this report can provide useful experience for developers and researchers in practical scenes, and we also provide deploy versions with ONNX, TensorRT, NCNN, and Openvino supported. + +
+ +
+ +
+ +YOLOX-l model structure +
+ +## 🥳 🚀 Results and Models + +| Backbone | Size | Batch Size | AMP | RTMDet-Hyp | Mem (GB) | Box AP | Config | Download | +| :--------: | :--: | :--------: | :-: | :--------: | :------: | :---------: | :-------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOX-tiny | 416 | 8xb8 | No | No | 2.8 | 32.7 | [config](./yolox_tiny_fast_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_8xb8-300e_coco/yolox_tiny_8xb8-300e_coco_20220919_090908-0e40a6fc.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_8xb8-300e_coco/yolox_tiny_8xb8-300e_coco_20220919_090908.log.json) | +| YOLOX-tiny | 416 | 8xb32 | Yes | Yes | 4.9 | 34.3 (+1.6) | [config](./yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco_20230210_143637-4c338102.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco_20230210_143637.log.json) | +| YOLOX-s | 640 | 8xb8 | Yes | No | 2.9 | 40.7 | [config](./yolox_s_fast_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb8-300e_coco/yolox_s_fast_8xb8-300e_coco_20230213_142600-2b224d8b.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb8-300e_coco/yolox_s_fast_8xb8-300e_coco_20230213_142600.log.json) | +| YOLOX-s | 640 | 8xb32 | Yes | Yes | 9.8 | 41.9 (+1.2) | [config](./yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco_20230210_134645-3a8dfbd7.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco_20230210_134645.log.json) | +| YOLOX-m | 640 | 8xb8 | Yes | No | 4.9 | 46.9 | [config](./yolox_m_fast_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb8-300e_coco/yolox_m_fast_8xb8-300e_coco_20230213_160218-a71a6b25.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb8-300e_coco/yolox_m_fast_8xb8-300e_coco_20230213_160218.log.json) | +| YOLOX-m | 640 | 8xb32 | Yes | Yes | 17.6 | 47.5 (+0.6) | [config](./yolox_m_fast_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco_20230210_144328-e657e182.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco_20230210_144328.log.json) | +| YOLOX-l | 640 | 8xb8 | Yes | No | 8.0 | 50.1 | [config](./yolox_l_fast_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_l_fast_8xb8-300e_coco/yolox_l_fast_8xb8-300e_coco_20230213_160715-c731eb1c.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_l_fast_8xb8-300e_coco/yolox_l_fast_8xb8-300e_coco_20230213_160715.log.json) | +| YOLOX-x | 640 | 8xb8 | Yes | No | 9.8 | 51.4 | [config](./yolox_x_fast_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_x_fast_8xb8-300e_coco/yolox_x_fast_8xb8-300e_coco_20230215_133950-1d509fab.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/yolox_x_fast_8xb8-300e_coco/yolox_x_fast_8xb8-300e_coco_20230215_133950.log.json) | + +YOLOX uses a default training configuration of `8xbs8` which results in a long training time, we expect it to use `8xbs32` to speed up the training and not cause a decrease in mAP. We modified `train_batch_size_per_gpu` from 8 to 32, `batch_augments_interval` from 10 to 1 and `base_lr` from 0.01 to 0.04 under YOLOX-s default configuration based on the linear scaling rule, which resulted in mAP degradation. Finally, I found that using RTMDet's training hyperparameter can improve performance in YOLOX Tiny/S/M, which also validates the superiority of RTMDet's training hyperparameter. + +The modified training parameters are as follows： + +1. train_batch_size_per_gpu: 8 -> 32 +2. batch_augments_interval: 10 -> 1 +3. num_last_epochs: 15 -> 20 +4. optim cfg: SGD -> AdamW, base_lr 0.01 -> 0.004, weight_decay 0.0005 -> 0.05 +5. ema momentum: 0.0001 -> 0.0002 + +**Note**: + +1. The test score threshold is 0.001. +2. Due to the need for pre-training weights, we cannot reproduce the performance of the `yolox-nano` model. Please refer to https://github.com/Megvii-BaseDetection/YOLOX/issues/674 for more information. + +## YOLOX-Pose + +Based on [MMPose](https://github.com/open-mmlab/mmpose/blob/main/projects/yolox-pose/README.md), we have implemented a YOLOX-based human pose estimator, utilizing the approach outlined in **YOLO-Pose: Enhancing YOLO for Multi Person Pose Estimation Using Object Keypoint Similarity Loss (CVPRW 2022)**. This pose estimator is lightweight and quick, making it well-suited for crowded scenes. + +
+ +
+ +### Results + +| Backbone | Size | Batch Size | AMP | RTMDet-Hyp | Mem (GB) | AP | Config | Download | +| :--------: | :--: | :--------: | :-: | :--------: | :------: | :--: | :------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOX-tiny | 416 | 8xb32 | Yes | Yes | 5.3 | 52.8 | [config](./pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco_20230427_080351-2117af67.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco_20230427_080351.log.json) | +| YOLOX-s | 640 | 8xb32 | Yes | Yes | 10.7 | 63.7 | [config](./pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco_20230427_005150-e87d843a.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco_20230427_005150.log.json) | +| YOLOX-m | 640 | 8xb32 | Yes | Yes | 19.2 | 69.3 | [config](./pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco_20230427_094024-bbeacc1c.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco_20230427_094024.log.json) | +| YOLOX-l | 640 | 8xb32 | Yes | Yes | 30.3 | 71.1 | [config](./pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco_20230427_041140-82d65ac8.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco_20230427_041140.log.json) | + +**Note** + +1. The performance is unstable and may fluctuate and the highest performance weight in `COCO` training may not be the last epoch. The performance shown above is the best model. + +### Installation + +Install MMPose + +``` +mim install -r requirements/mmpose.txt +``` + +## Citation + +```latex +@article{yolox2021, + title={{YOLOX}: Exceeding YOLO Series in 2021}, + author={Ge, Zheng and Liu, Songtao and Wang, Feng and Li, Zeming and Sun, Jian}, + journal={arXiv preprint arXiv:2107.08430}, + year={2021} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/metafile.yml b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/metafile.yml new file mode 100644 index 0000000000000000000000000000000000000000..78ede704a629fa44957bc2b24e05e6559fc17710 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/metafile.yml @@ -0,0 +1,166 @@ +Collections: + - Name: YOLOX + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - Cosine Annealing Lr Updater + Training Resources: 8x A100 GPUs + Architecture: + - CSPDarkNet + - PAFPN + Paper: + URL: https://arxiv.org/abs/2107.08430 + Title: 'YOLOX: Exceeding YOLO Series in 2021' + README: configs/yolox/README.md + Code: + URL: https://github.com/open-mmlab/mmyolo/blob/v0.1.0/mmyolo/models/detectors/yolo_detector.py#L12 + Version: v0.1.0 + + +Models: + - Name: yolox_tiny_fast_8xb8-300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_tiny_fast_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 2.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 32.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_8xb8-300e_coco/yolox_tiny_8xb8-300e_coco_20220919_090908-0e40a6fc.pth + - Name: yolox_s_fast_8xb8-300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_s_fast_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 2.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb8-300e_coco/yolox_s_fast_8xb8-300e_coco_20230213_142600-2b224d8b.pth + - Name: yolox_m_fast_8xb8-300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_m_fast_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 4.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.9 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb8-300e_coco/yolox_m_fast_8xb8-300e_coco_20230213_160218-a71a6b25.pth + - Name: yolox_l_fast_8xb8-300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_l_fast_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 8.0 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_l_fast_8xb8-300e_coco/yolox_l_fast_8xb8-300e_coco_20230213_160715-c731eb1c.pth + - Name: yolox_x_fast_8xb8-300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_x_fast_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 9.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.4 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_x_fast_8xb8-300e_coco/yolox_x_fast_8xb8-300e_coco_20230215_133950-1d509fab.pth + - Name: yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: configs/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 4.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 34.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco_20230210_143637-4c338102.pth + - Name: yolox_s_fast_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: configs/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 9.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco_20230210_134645-3a8dfbd7.pth + - Name: yolox_m_fast_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: configs/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 17.6 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.5 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco_20230210_144328-e657e182.pth + - Name: yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 5.3 + Epochs: 300 + Results: + - Task: Human Pose Estimation + Dataset: COCO + Metrics: + AP: 52.8 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco_20230427_080351-2117af67.pth + - Name: yolox-pose_s_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 10.7 + Epochs: 300 + Results: + - Task: Human Pose Estimation + Dataset: COCO + Metrics: + AP: 63.7 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco_20230427_005150-e87d843a.pth + - Name: yolox-pose_m_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: yolox-pose_m_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 19.2 + Epochs: 300 + Results: + - Task: Human Pose Estimation + Dataset: COCO + Metrics: + AP: 69.3 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco_20230427_094024-bbeacc1c.pth + - Name: yolox-pose_l_8xb32-300e-rtmdet-hyp_coco + In Collection: YOLOX + Config: yolox-pose_l_8xb32-300e-rtmdet-hyp_coco.py + Metadata: + Training Memory (GB): 30.3 + Epochs: 300 + Results: + - Task: Human Pose Estimation + Dataset: COCO + Metrics: + AP: 71.1 + Weights: https://download.openmmlab.com/mmyolo/v0/yolox/pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco_20230427_041140-82d65ac8.pth diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..96de5e98183b33d6c19865547e7f7e217be31ea5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_l_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,14 @@ +_base_ = ['./yolox-pose_m_8xb32-300e-rtmdet-hyp_coco.py'] + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolox/yolox_l_fast_8xb8-300e_coco/yolox_l_fast_8xb8-300e_coco_20230213_160715-c731eb1c.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 1.0 +widen_factor = 1.0 + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..f78d6a3a2f8ce2828839073f1fe2582f49bb5a69 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_m_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,14 @@ +_base_ = ['./yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py'] + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco_20230210_144328-e657e182.pth' # noqa + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..8fa2172c989ddfa6c6b28e33654e1c14b8cbbc91 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,136 @@ +_base_ = '../yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py' + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco_20230210_134645-3a8dfbd7.pth' # noqa + +num_keypoints = 17 +scaling_ratio_range = (0.75, 1.0) +mixup_ratio_range = (0.8, 1.6) +num_last_epochs = 20 + +# model settings +model = dict( + bbox_head=dict( + type='YOLOXPoseHead', + head_module=dict( + type='YOLOXPoseHeadModule', + num_classes=1, + num_keypoints=num_keypoints, + ), + loss_pose=dict( + type='OksLoss', + metainfo='configs/_base_/pose/coco.py', + loss_weight=30.0)), + train_cfg=dict( + assigner=dict( + type='PoseSimOTAAssigner', + center_radius=2.5, + oks_weight=3.0, + iou_calculator=dict(type='mmdet.BboxOverlaps2D'), + oks_calculator=dict( + type='OksLoss', metainfo='configs/_base_/pose/coco.py'))), + test_cfg=dict(score_thr=0.01)) + +# pipelines +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_keypoints=True) +] + +img_scale = _base_.img_scale + +train_pipeline_stage1 = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='RandomAffine', + scaling_ratio_range=scaling_ratio_range, + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='YOLOXMixUp', + img_scale=img_scale, + ratio_range=mixup_ratio_range, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='FilterAnnotations', by_keypoints=True, keep_empty=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape')) +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='FilterAnnotations', by_keypoints=True, keep_empty=False), + dict(type='PackDetInputs') +] + +test_pipeline = [ + *pre_transform, + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict( + type='PackDetInputs', + meta_keys=('id', 'img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip_indices')) +] + +# dataset settings +dataset_type = 'PoseCocoDataset' + +train_dataloader = dict( + dataset=dict( + type=dataset_type, + data_mode='bottomup', + ann_file='annotations/person_keypoints_train2017.json', + pipeline=train_pipeline_stage1)) + +val_dataloader = dict( + dataset=dict( + type=dataset_type, + data_mode='bottomup', + ann_file='annotations/person_keypoints_val2017.json', + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# evaluators +val_evaluator = dict( + _delete_=True, + type='mmpose.CocoMetric', + ann_file=_base_.data_root + 'annotations/person_keypoints_val2017.json', + score_mode='bbox') +test_evaluator = val_evaluator + +default_hooks = dict(checkpoint=dict(save_best='coco/AP', rule='greater')) + +visualizer = dict(type='mmpose.PoseLocalVisualizer') + +custom_hooks = [ + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=num_last_epochs, + new_train_pipeline=train_pipeline_stage2, + priority=48), + dict(type='mmdet.SyncNormHook', priority=48), + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + strict_load=False, + priority=49) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..a7399065e70f40f4142abc943b572cbd93954222 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/pose/yolox-pose_tiny_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,70 @@ +_base_ = './yolox-pose_s_8xb32-300e-rtmdet-hyp_coco.py' + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco_20230210_143637-4c338102.pth' # noqa + +deepen_factor = 0.33 +widen_factor = 0.375 +scaling_ratio_range = (0.75, 1.0) + +# model settings +model = dict( + data_preprocessor=dict(batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + random_size_range=(320, 640), + size_divisor=32, + interval=1) + ]), + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + ), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +# data settings +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform + +train_pipeline_stage1 = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='RandomAffine', + scaling_ratio_range=scaling_ratio_range, + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict( + type='FilterAnnotations', + by_keypoints=True, + min_gt_bbox_wh=(1, 1), + keep_empty=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape')) +] + +test_pipeline = [ + *pre_transform, + dict(type='Resize', scale=(416, 416), keep_ratio=True), + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict( + type='PackDetInputs', + meta_keys=('id', 'img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip_indices')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline_stage1)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_l_fast_8xb8-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_l_fast_8xb8-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..39198d2e245b00445f0a5d38e41a1ffe389b17de --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_l_fast_8xb8-300e_coco.py @@ -0,0 +1,12 @@ +_base_ = './yolox_s_fast_8xb8-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 1.0 +widen_factor = 1.0 + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..4a4743c2dd4bcbe9e692aff54e3af1909d540c60 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_m_fast_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,12 @@ +_base_ = './yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_m_fast_8xb8-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_m_fast_8xb8-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..ec8fd2c854bc2d41d53ba481fa3ad7f23ba3c54a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_m_fast_8xb8-300e_coco.py @@ -0,0 +1,12 @@ +_base_ = './yolox_s_fast_8xb8-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.67 +widen_factor = 0.75 + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_nano_fast_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_nano_fast_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..851664fb3cb03dc24c4ea03e158b08db011684e9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_nano_fast_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.25 +use_depthwise = True + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + use_depthwise=use_depthwise), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + use_depthwise=use_depthwise), + bbox_head=dict( + head_module=dict( + widen_factor=widen_factor, use_depthwise=use_depthwise))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_nano_fast_8xb8-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_nano_fast_8xb8-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..a0a5d373856343af82259f9c165f851be49de16d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_nano_fast_8xb8-300e_coco.py @@ -0,0 +1,21 @@ +_base_ = './yolox_tiny_fast_8xb8-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.25 +use_depthwise = True + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + use_depthwise=use_depthwise), + neck=dict( + deepen_factor=deepen_factor, + widen_factor=widen_factor, + use_depthwise=use_depthwise), + bbox_head=dict( + head_module=dict( + widen_factor=widen_factor, use_depthwise=use_depthwise))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_p5_tta.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_p5_tta.py new file mode 100644 index 0000000000000000000000000000000000000000..7ffe3490ca3f7f059d498201277f4df86fbcd3da --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_p5_tta.py @@ -0,0 +1,56 @@ +# TODO: Need to solve the problem of multiple backend_args parameters +# _backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) + +_backend_args = None + +tta_model = dict( + type='mmdet.DetTTAModel', + tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.65), max_per_img=300)) + +img_scales = [(640, 640), (320, 320), (960, 960)] + +# LoadImageFromFile +# / | \ +# Resize Resize Resize # noqa +# / \ / \ / \ +# RandomFlip RandomFlip RandomFlip RandomFlip RandomFlip RandomFlip # noqa +# | | | | | | +# LoadAnn LoadAnn LoadAnn LoadAnn LoadAnn LoadAnn +# | | | | | | +# PackDetIn PackDetIn PackDetIn PackDetIn PackDetIn PackDetIn # noqa + +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_backend_args), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='mmdet.Resize', scale=s, keep_ratio=True) + for s in img_scales + ], + [ + # ``RandomFlip`` must be placed before ``Pad``, otherwise + # bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], + [ + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + ], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction')) + ] + ]) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_1xb12-40e-rtmdet-hyp_cat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_1xb12-40e-rtmdet-hyp_cat.py new file mode 100644 index 0000000000000000000000000000000000000000..f7eac58fb548a034e22acccef72a32951bb80dee --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_1xb12-40e-rtmdet-hyp_cat.py @@ -0,0 +1,76 @@ +_base_ = './yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py' + +data_root = './data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +num_last_epochs = 5 + +max_epochs = 40 +train_batch_size_per_gpu = 12 +train_num_workers = 4 + +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco_20230210_134645-3a8dfbd7.pth' # noqa + +model = dict( + backbone=dict(frozen_stages=4), + bbox_head=dict(head_module=dict(num_classes=num_classes))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +param_scheduler = [ + dict( + # use quadratic formula to warm up 3 epochs + # and lr is updated by iteration + # TODO: fix default scope in get function + type='mmdet.QuadraticWarmupLR', + by_epoch=True, + begin=0, + end=3, + convert_to_iter_based=True), + dict( + # use cosine lr from 5 to 35 epoch + type='CosineAnnealingLR', + eta_min=_base_.base_lr * 0.05, + begin=5, + T_max=max_epochs - num_last_epochs, + end=max_epochs - num_last_epochs, + by_epoch=True, + convert_to_iter_based=True), + dict( + # use fixed lr during last num_last_epochs epochs + type='ConstantLR', + by_epoch=True, + factor=1, + begin=max_epochs - num_last_epochs, + end=max_epochs, + ) +] + +_base_.custom_hooks[0].num_last_epochs = num_last_epochs + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +# visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) # noqa diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..167023da94815e13a782b85209e1116aeac7803d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,87 @@ +_base_ = './yolox_s_fast_8xb8-300e_coco.py' + +# ========================modified parameters====================== +# Batch size of a single GPU during training +# 8 -> 32 +train_batch_size_per_gpu = 32 + +# Multi-scale training intervals +# 10 -> 1 +batch_augments_interval = 1 + +# Last epoch number to switch training pipeline +# 15 -> 20 +num_last_epochs = 20 + +# Base learning rate for optim_wrapper. Corresponding to 8xb32=256 bs +base_lr = 0.004 + +# SGD -> AdamW +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=base_lr, weight_decay=0.05), + paramwise_cfg=dict( + norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True)) + +# 0.0001 -> 0.0002 +ema_momentum = 0.0002 + +# ============================== Unmodified in most cases =================== +model = dict( + data_preprocessor=dict(batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + random_size_range=(480, 800), + size_divisor=32, + interval=batch_augments_interval) + ])) + +param_scheduler = [ + dict( + # use quadratic formula to warm up 5 epochs + # and lr is updated by iteration + # TODO: fix default scope in get function + type='mmdet.QuadraticWarmupLR', + by_epoch=True, + begin=0, + end=5, + convert_to_iter_based=True), + dict( + # use cosine lr from 5 to 285 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=5, + T_max=_base_.max_epochs - num_last_epochs, + end=_base_.max_epochs - num_last_epochs, + by_epoch=True, + convert_to_iter_based=True), + dict( + # use fixed lr during last num_last_epochs epochs + type='ConstantLR', + by_epoch=True, + factor=1, + begin=_base_.max_epochs - num_last_epochs, + end=_base_.max_epochs, + ) +] + +custom_hooks = [ + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=num_last_epochs, + new_train_pipeline=_base_.train_pipeline_stage2, + priority=48), + dict(type='mmdet.SyncNormHook', priority=48), + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=ema_momentum, + update_buffers=True, + strict_load=False, + priority=49) +] + +train_dataloader = dict(batch_size=train_batch_size_per_gpu) +train_cfg = dict(dynamic_intervals=[(_base_.max_epochs - num_last_epochs, 1)]) +auto_scale_lr = dict(base_batch_size=8 * train_batch_size_per_gpu) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_8xb8-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_8xb8-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..b371ea11d2dd0900476d88a9de626e881297d790 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_s_fast_8xb8-300e_coco.py @@ -0,0 +1,331 @@ +_base_ = ['../_base_/default_runtime.py', 'yolox_p5_tta.py'] + +# ========================Frequently modified parameters====================== +# -----data related----- +data_root = 'data/coco/' # Root path of data +# path of train annotation file +train_ann_file = 'annotations/instances_train2017.json' +train_data_prefix = 'train2017/' # Prefix of train image path +# path of val annotation file +val_ann_file = 'annotations/instances_val2017.json' +val_data_prefix = 'val2017/' # Prefix of train image path + +num_classes = 80 # Number of classes for classification +# Batch size of a single GPU during training +train_batch_size_per_gpu = 8 +# Worker to pre-fetch data for each single GPU during tarining +train_num_workers = 8 +# Presistent_workers must be False if num_workers is 0 +persistent_workers = True + +# -----train val related----- +# Base learning rate for optim_wrapper. Corresponding to 8xb16=64 bs +base_lr = 0.01 +max_epochs = 300 # Maximum training epochs + +model_test_cfg = dict( + yolox_style=True, # better + # The config of multi-label for multi-class prediction + multi_label=True, # 40.5 -> 40.7 + score_thr=0.001, # Threshold to filter out boxes + max_per_img=300, # Max number of detections of each image + nms=dict(type='nms', iou_threshold=0.65)) # NMS type and threshold + +# ========================Possible modified parameters======================== +# -----data related----- +img_scale = (640, 640) # width, height +# Dataset type, this will be used to define the dataset +dataset_type = 'YOLOv5CocoDataset' +# Batch size of a single GPU during validation +val_batch_size_per_gpu = 1 +# Worker to pre-fetch data for each single GPU during validation +val_num_workers = 2 + +# -----model related----- +# The scaling factor that controls the depth of the network structure +deepen_factor = 0.33 +# The scaling factor that controls the width of the network structure +widen_factor = 0.5 +norm_cfg = dict(type='BN', momentum=0.03, eps=0.001) +# generate new random resize shape interval +batch_augments_interval = 10 + +# -----train val related----- +weight_decay = 0.0005 +loss_cls_weight = 1.0 +loss_bbox_weight = 5.0 +loss_obj_weight = 1.0 +loss_bbox_aux_weight = 1.0 +center_radius = 2.5 # SimOTAAssigner +num_last_epochs = 15 +random_affine_scaling_ratio_range = (0.1, 2) +mixup_ratio_range = (0.8, 1.6) +# Save model checkpoint and validation intervals +save_epoch_intervals = 10 +# The maximum checkpoints to keep. +max_keep_ckpts = 3 + +ema_momentum = 0.0001 + +# ===============================Unmodified in most cases==================== +# model settings +model = dict( + type='YOLODetector', + init_cfg=dict( + type='Kaiming', + layer='Conv2d', + a=2.23606797749979, # math.sqrt(5) + distribution='uniform', + mode='fan_in', + nonlinearity='leaky_relu'), + # TODO: Waiting for mmengine support + use_syncbn=False, + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + random_size_range=(480, 800), + size_divisor=32, + interval=batch_augments_interval) + ]), + backbone=dict( + type='YOLOXCSPDarknet', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + out_indices=(2, 3, 4), + spp_kernal_sizes=(5, 9, 13), + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + ), + neck=dict( + type='YOLOXPAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=256, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='YOLOXHead', + head_module=dict( + type='YOLOXHeadModule', + num_classes=num_classes, + in_channels=256, + feat_channels=256, + widen_factor=widen_factor, + stacked_convs=2, + featmap_strides=(8, 16, 32), + use_depthwise=False, + norm_cfg=norm_cfg, + act_cfg=dict(type='SiLU', inplace=True), + ), + loss_cls=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='sum', + loss_weight=loss_cls_weight), + loss_bbox=dict( + type='mmdet.IoULoss', + mode='square', + eps=1e-16, + reduction='sum', + loss_weight=loss_bbox_weight), + loss_obj=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='sum', + loss_weight=loss_obj_weight), + loss_bbox_aux=dict( + type='mmdet.L1Loss', + reduction='sum', + loss_weight=loss_bbox_aux_weight)), + train_cfg=dict( + assigner=dict( + type='mmdet.SimOTAAssigner', + center_radius=center_radius, + iou_calculator=dict(type='mmdet.BboxOverlaps2D'))), + test_cfg=model_test_cfg) + +pre_transform = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True) +] + +train_pipeline_stage1 = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='mmdet.RandomAffine', + scaling_ratio_range=random_affine_scaling_ratio_range, + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='YOLOXMixUp', + img_scale=img_scale, + ratio_range=mixup_ratio_range, + pad_val=114.0, + pre_transform=pre_transform), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.FilterAnnotations', + min_gt_bbox_wh=(1, 1), + keep_empty=False), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +train_pipeline_stage2 = [ + *pre_transform, + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=True), + dict( + type='mmdet.Pad', + pad_to_square=True, + # If the image is three-channel, the pad value needs + # to be set separately for each channel. + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.FilterAnnotations', + min_gt_bbox_wh=(1, 1), + keep_empty=False), + dict(type='mmdet.PackDetInputs') +] + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + collate_fn=dict(type='yolov5_collate'), + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline_stage1)) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=True), + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=val_ann_file, + data_prefix=dict(img=val_data_prefix), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# Reduce evaluation time +val_evaluator = dict( + type='mmdet.CocoMetric', + proposal_nums=(100, 1, 10), + ann_file=data_root + val_ann_file, + metric='bbox') + +test_evaluator = val_evaluator + +# optimizer +# default 8 gpu +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', + lr=base_lr, + momentum=0.9, + weight_decay=weight_decay, + nesterov=True), + paramwise_cfg=dict(norm_decay_mult=0., bias_decay_mult=0.)) + +# learning rate +param_scheduler = [ + dict( + # use quadratic formula to warm up 5 epochs + # and lr is updated by iteration + # TODO: fix default scope in get function + type='mmdet.QuadraticWarmupLR', + by_epoch=True, + begin=0, + end=5, + convert_to_iter_based=True), + dict( + # use cosine lr from 5 to 285 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=5, + T_max=max_epochs - num_last_epochs, + end=max_epochs - num_last_epochs, + by_epoch=True, + convert_to_iter_based=True), + dict( + # use fixed lr during last 15 epochs + type='ConstantLR', + by_epoch=True, + factor=1, + begin=max_epochs - num_last_epochs, + end=max_epochs, + ) +] + +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + max_keep_ckpts=max_keep_ckpts, + save_best='auto')) + +custom_hooks = [ + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=num_last_epochs, + new_train_pipeline=train_pipeline_stage2, + priority=48), + dict(type='mmdet.SyncNormHook', priority=48), + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=ema_momentum, + update_buffers=True, + strict_load=False, + priority=49) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=save_epoch_intervals, + dynamic_intervals=[(max_epochs - num_last_epochs, 1)]) + +auto_scale_lr = dict(base_batch_size=8 * train_batch_size_per_gpu) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..28e539c9472d20fe2e28b49659ec523c098bb170 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_tiny_fast_8xb32-300e-rtmdet-hyp_coco.py @@ -0,0 +1,70 @@ +_base_ = './yolox_s_fast_8xb32-300e-rtmdet-hyp_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.375 + +# Multi-scale training intervals +# 10 -> 1 +batch_augments_interval = 1 + +scaling_ratio_range = (0.5, 1.5) + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform + +# model settings +model = dict( + data_preprocessor=dict(batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + random_size_range=(320, 640), + size_divisor=32, + interval=batch_augments_interval) + ]), + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_pipeline_stage1 = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='mmdet.RandomAffine', + scaling_ratio_range=scaling_ratio_range, # note + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.FilterAnnotations', + min_gt_bbox_wh=(1, 1), + keep_empty=False), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=(416, 416), keep_ratio=True), # note + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline_stage1)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_tiny_fast_8xb8-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_tiny_fast_8xb8-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..fd175a6c73ccc55df697ccbf04dfb46a3fbdc0ee --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_tiny_fast_8xb8-300e_coco.py @@ -0,0 +1,100 @@ +_base_ = './yolox_s_fast_8xb8-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 0.33 +widen_factor = 0.375 +scaling_ratio_range = (0.5, 1.5) + +# =======================Unmodified in most cases================== +img_scale = _base_.img_scale +pre_transform = _base_.pre_transform + +test_img_scale = (416, 416) +tta_img_scales = [test_img_scale, (320, 320), (640, 640)] + +# model settings +model = dict( + data_preprocessor=dict(batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + random_size_range=(320, 640), + size_divisor=32, + interval=10) + ]), + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) + +train_pipeline_stage1 = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='mmdet.RandomAffine', + scaling_ratio_range=scaling_ratio_range, # note + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict(type='mmdet.YOLOXHSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.FilterAnnotations', + min_gt_bbox_wh=(1, 1), + keep_empty=False), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=test_img_scale, keep_ratio=True), # note + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline_stage1)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# Config for Test Time Augmentation. (TTA) +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='mmdet.Resize', scale=s, keep_ratio=True) + for s in tta_img_scales + ], + [ + # ``RandomFlip`` must be placed before ``Pad``, otherwise + # bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], + [ + dict( + type='mmdet.Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + ], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction')) + ] + ]) +] diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_x_fast_8xb8-300e_coco.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_x_fast_8xb8-300e_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..0759d468be70f9af026fef2ae0dbf2308082ad96 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/configs/yolox/yolox_x_fast_8xb8-300e_coco.py @@ -0,0 +1,12 @@ +_base_ = './yolox_s_fast_8xb8-300e_coco.py' + +# ========================modified parameters====================== +deepen_factor = 1.33 +widen_factor = 1.25 + +# =======================Unmodified in most cases================== +# model settings +model = dict( + backbone=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + neck=dict(deepen_factor=deepen_factor, widen_factor=widen_factor), + bbox_head=dict(head_module=dict(widen_factor=widen_factor))) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/15_minutes_instance_segmentation.ipynb b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/15_minutes_instance_segmentation.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..a09a1a10512c15abd611c35cefdfbeda64090268 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/15_minutes_instance_segmentation.ipynb @@ -0,0 +1,658 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "x7seefPduh36" + }, + "source": [ + "
\n", + " \n", + "
 
\n", + "
\n", + " OpenMMLab website\n", + " \n", + " \n", + " HOT\n", + " \n", + " \n", + "     \n", + " OpenMMLab platform\n", + " \n", + " \n", + " TRY IT OUT\n", + " \n", + " \n", + "
\n", + "
 
\n", + "\n", + "\"Open\n", + "\n", + "[![PyPI](https://img.shields.io/pypi/v/mmyolo)](https://pypi.org/project/mmyolo)\n", + "[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmyolo.readthedocs.io/en/latest/)\n", + "[![deploy](https://github.com/open-mmlab/mmyolo/workflows/deploy/badge.svg)](https://github.com/open-mmlab/mmyolo/actions)\n", + "[![codecov](https://codecov.io/gh/open-mmlab/mmyolo/branch/main/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmyolo)\n", + "[![license](https://img.shields.io/github/license/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/blob/main/LICENSE)\n", + "[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues)\n", + "[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues)\n", + "\n", + "[📘Documentation](https://mmyolo.readthedocs.io/en/latest/) |\n", + "[🛠️Installation](https://mmyolo.readthedocs.io/en/latest/get_started/installation.html) |\n", + "[👀Model Zoo](https://mmyolo.readthedocs.io/en/latest/model_zoo.html) |\n", + "[🆕Update News](https://mmyolo.readthedocs.io/en/latest/notes/changelog.html) |\n", + "[🤔Reporting Issues](https://github.com/open-mmlab/mmyolo/issues/new/choose)\n", + "\n", + "
\n", + "\n", + "
\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + "
" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "V6W8P5XEJGoc" + }, + "source": [ + "# 15 minutes to get started with MMYOLO instance segmentation\n", + "\n", + "Instance segmentation is a task in computer vision that aims to segment each object in an image and assign each object a unique identifier.\n", + "\n", + "Unlike semantic segmentation, instance segmentation not only segments out different categories in an image, but also separates different instances of the same category.\n", + "\n", + "
\n", + "\"Instance\n", + "
\n", + "\n", + "Taking the downloadable balloon dataset as an example, I will guide you through a 15-minute easy introduction to MMYOLO instance segmentation. The entire process includes the following steps:\n", + "\n", + "- [Installation](#installation)\n", + "- [Dataset](#dataset)\n", + "- [Config](#config)\n", + "- [Training](#training)\n", + "- [Testing](#testing)\n", + "- [EasyDeploy](#easydeploy-deployment)\n", + "\n", + "In this tutorial, we will use YOLOv5-s as an example. For the demo configuration of the balloon dataset with other YOLO series algorithms, please refer to the corresponding algorithm configuration folder." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Ae5SqsA7wYGQ" + }, + "source": [ + "## Installation\n", + "\n", + "Assuming you've already installed Conda in advance, then install PyTorch using the following commands." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XVLRaEIzwW-6", + "outputId": "901b5db6-b1d7-4830-e746-485ee76d6648" + }, + "outputs": [], + "source": [ + "# -----------------------------------------------------------------------------------------\n", + "# If you are using colab, you can skip this cell for PyTorch is pre-installed on the colab.\n", + "# -----------------------------------------------------------------------------------------\n", + "!python -V\n", + "# Check nvcc version\n", + "!nvcc -V\n", + "# Check GCC version\n", + "!gcc --version\n", + "# Create a new Conda environment\n", + "%conda create -n mmyolo python=3.8 -y\n", + "%conda activate mmyolo\n", + "# If you have GPU\n", + "%conda install pytorch torchvision -c pytorch\n", + "# If you only have CPU\n", + "# %conda install pytorch torchvision cpuonly -c pytorch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check PyTorch version\n", + "import torch\n", + "print(torch.__version__)\n", + "print(torch.cuda.is_available())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install MMYOLO and dependency libraries using the following commands.\n", + "For details about how to configure the environment, see [Installation and verification](https://mmyolo.readthedocs.io/en/latest/get_started/installation.html).\n", + "```{note}\n", + "Note: Since this repo uses OpenMMLab 2.0, it is better to create a new conda virtual environment to prevent conflicts with the repo installed in OpenMMLab 1.0.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-qATUuntwmfD", + "outputId": "24be577b-efce-46f2-8b2f-a65d02824467" + }, + "outputs": [], + "source": [ + "!git clone https://github.com/open-mmlab/mmyolo.git\n", + "%cd mmyolo\n", + "%pip install -U openmim\n", + "!mim install -r requirements/mminstall.txt\n", + "# Install albumentations\n", + "!mim install -r requirements/albu.txt\n", + "# Install MMYOLO\n", + "!mim install -v -e .\n", + "# \"-v\" means verbose, or more output\n", + "# \"-e\" means installing a project in editable mode,\n", + "# thus any local modifications made to the code will take effect without reinstallation." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset\n", + "\n", + "The Balloon dataset is a single-class dataset that consists of 74 images and includes annotated information required for training. Here is an example image from the dataset:\n", + "\n", + "
\n", + "\"balloon\n", + "
\n", + "\n", + "You can download and use it directly by the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gMQXwWuIw3ef", + "outputId": "c8efeac7-5b0c-4342-b5af-d3e790e358c3" + }, + "outputs": [], + "source": [ + "!python tools/misc/download_dataset.py --dataset-name balloon --save-dir ./data/balloon --unzip --delete\n", + "!python ./tools/dataset_converters/balloon2coco.py" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "covQskXXw2ul" + }, + "source": [ + "The data for the MMYOLO project is located in the MMYOLO project directory. The `train.json` and `val.json` files store the annotations in COCO format, while the `data/balloon/train` and `data/balloon/val` directories contain all the images for the dataset.\n", + "\n", + "## Config\n", + "\n", + "Taking YOLOv5 algorithm as an example, considering the limited GPU memory of users, we need to modify some default training parameters to make them run smoothly. The key parameters to be modified are as follows:\n", + "\n", + "- YOLOv5 is an Anchor-Based algorithm, and different datasets need to calculate suitable anchors adaptively.\n", + "- The default config uses 8 GPUs with a batch size of 16 per GPU. Now change it to a single GPU with a batch size of 12.\n", + "- In principle, the learning rate should be linearly scaled accordingly when the batch size is changed, but actual measurements have found that this is not necessary.\n", + "\n", + "To perform the specific operation, create a new configuration file named `yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py` in the `configs/yolov5/ins_seg` folder. For convenience, we have already provided this configuration file. Copy the following contents into the configuration file.\n", + "\n", + "```python\n", + "_base_ = './yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa\n", + "\n", + "data_root = 'data/balloon/' # dataset root\n", + "# Training set annotation file of json path\n", + "train_ann_file = 'train.json'\n", + "train_data_prefix = 'train/' # Dataset prefix\n", + "# Validation set annotation file of json path\n", + "val_ann_file = 'val.json'\n", + "val_data_prefix = 'val/'\n", + "metainfo = {\n", + " 'classes': ('balloon', ), # dataset category name\n", + " 'palette': [\n", + " (220, 20, 60),\n", + " ]\n", + "}\n", + "num_classes = 1\n", + "# Set batch size to 4\n", + "train_batch_size_per_gpu = 4\n", + "# dataloader num workers\n", + "train_num_workers = 2\n", + "log_interval = 1\n", + "#####################\n", + "train_dataloader = dict(\n", + " batch_size=train_batch_size_per_gpu,\n", + " num_workers=train_num_workers,\n", + " dataset=dict(\n", + " data_root=data_root,\n", + " metainfo=metainfo,\n", + " data_prefix=dict(img=train_data_prefix),\n", + " ann_file=train_ann_file))\n", + "val_dataloader = dict(\n", + " dataset=dict(\n", + " data_root=data_root,\n", + " metainfo=metainfo,\n", + " data_prefix=dict(img=val_data_prefix),\n", + " ann_file=val_ann_file))\n", + "test_dataloader = val_dataloader\n", + "val_evaluator = dict(ann_file=data_root + val_ann_file)\n", + "test_evaluator = val_evaluator\n", + "default_hooks = dict(logger=dict(interval=log_interval))\n", + "#####################\n", + "\n", + "model = dict(bbox_head=dict(head_module=dict(num_classes=num_classes)))\n", + "```\n", + "\n", + "The above configuration inherits from `yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py` and updates configurations such as `data_root`, `metainfo`, `train_dataloader`, `val_dataloader`, `num_classes`, etc., based on the characteristics of the balloon dataset.\n", + "\n", + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "TQ0h6sv_rJxq" + }, + "source": [ + "After running the training command mentioned above, the folder `work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance` will be automatically generated. The weight files and the training configuration file for this session will be saved in this folder. On a lower-end GPU like the GTX 1660, the entire training process will take approximately 30 minutes.\n", + "\n", + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "The performance on `val.json` is as follows:\n", + "\n", + "```text\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.330\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.509\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.317\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.103\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.417\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.150\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.396\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.454\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.317\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n", + "```\n", + "\n", + "The above performance is obtained by printing using the COCO API, where -1 indicates the absence of objects of that scale.\n", + "\n", + "### Some Notes\n", + "\n", + "Two key warnings are printed during training:\n", + "\n", + "- You are using `YOLOv5Head` with num_classes == 1. The loss_cls will be 0. This is a normal phenomenon.\n", + "\n", + "The warning is because the `num_classes` currently trained is 1, the loss of the classification branch is always 0 according to the community of the YOLOv5 algorithm, which is a normal phenomenon.\n", + "\n", + "### Training is resumed after the interruption\n", + "\n", + "If you stop training, you can add `--resume` to the end of the training command and the program will automatically resume training with the latest weights file from `work_dirs`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py --resume" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "3sJxvQoUrMhX" + }, + "source": [ + "### Save GPU memory strategy\n", + "\n", + "The above config requires about 3G RAM, so if you don't have enough, consider turning on mixed-precision training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py --amp" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "jVJdyHTxrQ9a" + }, + "source": [ + "### Training visualization\n", + "\n", + "MMYOLO currently supports local, TensorBoard, WandB and other back-end visualization. The default is to use local visualization, and you can switch to WandB and other real-time visualization of various indicators in the training process.\n", + "\n", + "#### 1 WandB\n", + "\n", + "WandB visualization need registered in website, and in the https://wandb.ai/settings for wandb API Keys.\n", + "\n", + "
\n", + "\"image\"/\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install wandb\n", + "# After running wandb login, enter the API Keys obtained above, and the login is successful.\n", + "!wandb login" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Yu0_4YYRrbyY" + }, + "source": [ + "Add the wandb config at the end of config file we just created: `configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py`.\n", + "\n", + "```python\n", + "visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')])\n", + "```\n", + "\n", + "Running the training command and you will see the loss, learning rate, and coco/bbox_mAP visualizations in the link." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "f_DyzfDIzwMa" + }, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "#### 2 Tensorboard\n", + "\n", + "Install Tensorboard using the following command." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "gHkGlii3n29Q" + }, + "outputs": [], + "source": [ + "%pip install tensorboard" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "bE-nx9TY1P-M" + }, + "source": [ + "Add the `tensorboard` config at the end of config file we just created: `configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py`.\n", + "\n", + "```python\n", + "visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')])\n", + "```\n", + "\n", + "After re-running the training command, Tensorboard file will be generated in the visualization folder `work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/{timestamp}/vis_data`.\n", + "We can use Tensorboard to view the loss, learning rate, and coco/bbox_mAP visualizations from a web link by running the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "g8fZgokho5CE" + }, + "outputs": [], + "source": [ + "!tensorboard --logdir=work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "GUZ7MPoaro-o" + }, + "source": [ + "## Testing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VYmxtE0GunTB", + "outputId": "f440807c-1931-4810-b76d-617f73fde227" + }, + "outputs": [], + "source": [ + "!python tools/test.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance best_coco_bbox_mAP_epoch_300.pth --show-dir show_results" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "_cFocUqN0BCb" + }, + "source": [ + "Run the above test command, you can not only get the AP performance printed in the **Training** section, You can also automatically save the result images to the `work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/{timestamp}/show_results` folder. Below is one of the result images, the left image is the actual annotation, and the right image is the inference result of the model.\n", + "\n", + "
\n", + "\"result_img\"/\n", + "
\n", + "\n", + "You can also visualize model inference results in a browser window if you use `WandbVisBackend` or `TensorboardVisBackend`.\n", + "\n", + "## Feature map visualization\n", + "\n", + "MMYOLO provides visualization scripts for feature map to analyze the current model training. Please refer to [Feature Map Visualization](../recommended_topics/visualization.md)\n", + "\n", + "Due to the bias of direct visualization of `test_pipeline`, we need to modify the `test_pipeline` of `configs/yolov5/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py`\n", + "\n", + "```python\n", + "test_pipeline = [\n", + " dict(\n", + " type='LoadImageFromFile',\n", + " file_client_args=_base_.file_client_args),\n", + " dict(type='YOLOv5KeepRatioResize', scale=img_scale),\n", + " dict(\n", + " type='LetterResize',\n", + " scale=img_scale,\n", + " allow_scale_up=False,\n", + " pad_val=dict(img=114)),\n", + " dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'),\n", + " dict(\n", + " type='mmdet.PackDetInputs',\n", + " meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n", + " 'scale_factor', 'pad_param'))\n", + "]\n", + "```\n", + "\n", + "to the following config:\n", + "\n", + "```python\n", + "test_pipeline = [\n", + " dict(\n", + " type='LoadImageFromFile',\n", + " file_client_args=_base_.file_client_args),\n", + " dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # modify the LetterResize to mmdet.Resize\n", + " dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'),\n", + " dict(\n", + " type='mmdet.PackDetInputs',\n", + " meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n", + " 'scale_factor'))\n", + "]\n", + "```\n", + "\n", + "Let's choose the `data/balloon/train/3927754171_9011487133_b.jpg` image as an example to visualize the output feature maps of YOLOv5 backbone and neck layers.\n", + "\n", + "**1. Visualize the three channels of YOLOv5 backbone**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python demo/featmap_vis_demo.py data/balloon/train/3927754171_9011487133_b.jpg onfigs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/best_coco_bbox_mAP_epoch_300.pth --target-layers backbone --channel-reduction squeeze_mean" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "The result will be saved to the output folder in current path. Three output feature maps plotted in the above figure correspond to small, medium and large output feature maps.\n", + "\n", + "**2. Visualize the three channels of YOLOv5 neck**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python demo/featmap_vis_demo.py data/balloon/train/3927754171_9011487133_b.jpg \\\n", + " configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py \\\n", + " work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/best_coco_bbox_mAP_epoch_300.pth \\\n", + " --target-layers neck \\\n", + " --channel-reduction squeeze_mean" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "**3. Grad-Based CAM visualization**\n", + "TODO" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## EasyDeploy deployment\n", + "TODO\n", + "\n", + "This completes the transformation deployment of the trained model and checks the inference results. This is the end of the tutorial.\n", + "\n", + "If you encounter problems during training or testing, please check the [common troubleshooting steps](https://mmyolo.readthedocs.io/en/dev/recommended_topics/troubleshooting_steps.html) first and feel free to open an [issue](https://github.com/open-mmlab/mmyolo/issues/new/choose) if you still can't solve it." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [], + "toc_visible": true + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/15_minutes_object_detection.ipynb b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/15_minutes_object_detection.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..47e0ccbd803c808982b2a30d55b640f0b1bd48da --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/15_minutes_object_detection.ipynb @@ -0,0 +1,1002 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "x7seefPduh36" + }, + "source": [ + "
\n", + " \n", + "
 
\n", + "
\n", + " OpenMMLab website\n", + " \n", + " \n", + " HOT\n", + " \n", + " \n", + "     \n", + " OpenMMLab platform\n", + " \n", + " \n", + " TRY IT OUT\n", + " \n", + " \n", + "
\n", + "
 
\n", + "\n", + "\"Open\n", + "\n", + "[![PyPI](https://img.shields.io/pypi/v/mmyolo)](https://pypi.org/project/mmyolo)\n", + "[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmyolo.readthedocs.io/en/latest/)\n", + "[![deploy](https://github.com/open-mmlab/mmyolo/workflows/deploy/badge.svg)](https://github.com/open-mmlab/mmyolo/actions)\n", + "[![codecov](https://codecov.io/gh/open-mmlab/mmyolo/branch/main/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmyolo)\n", + "[![license](https://img.shields.io/github/license/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/blob/main/LICENSE)\n", + "[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues)\n", + "[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmyolo.svg)](https://github.com/open-mmlab/mmyolo/issues)\n", + "\n", + "[📘Documentation](https://mmyolo.readthedocs.io/en/latest/) |\n", + "[🛠️Installation](https://mmyolo.readthedocs.io/en/latest/get_started/installation.html) |\n", + "[👀Model Zoo](https://mmyolo.readthedocs.io/en/latest/model_zoo.html) |\n", + "[🆕Update News](https://mmyolo.readthedocs.io/en/latest/notes/changelog.html) |\n", + "[🤔Reporting Issues](https://github.com/open-mmlab/mmyolo/issues/new/choose)\n", + "\n", + "
\n", + "\n", + "
\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + "
" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "V6W8P5XEJGoc" + }, + "source": [ + "# 15 minutes to get started with MMYOLO object detection\n", + "\n", + "Object detection task refers to that given a picture, the network predicts all the categories of objects included in the picture and the corresponding boundary boxes\n", + "\n", + "
\n", + "\"object\n", + "
\n", + "\n", + "Take the small dataset of cat as an example, you can easily learn MMYOLO object detection in 15 minutes. The whole process consists of the following steps:\n", + "\n", + "- [Installation](#installation)\n", + "- [Dataset](#dataset)\n", + "- [Config](#config)\n", + "- [Training](#training)\n", + "- [Testing](#testing)\n", + "- [EasyDeploy](#easydeploy-deployment)\n", + "\n", + "In this tutorial, we take YOLOv5-s as an example. For the rest of the YOLO series algorithms, please see the corresponding algorithm configuration folder." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Ae5SqsA7wYGQ" + }, + "source": [ + "## Installation\n", + "\n", + "Assuming you've already installed Conda in advance, then install PyTorch using the following commands." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XVLRaEIzwW-6", + "outputId": "901b5db6-b1d7-4830-e746-485ee76d6648" + }, + "outputs": [], + "source": [ + "# -----------------------------------------------------------------------------------------\n", + "# If you are using colab, you can skip this cell for PyTorch is pre-installed on the colab.\n", + "# -----------------------------------------------------------------------------------------\n", + "!python -V\n", + "# Check nvcc version\n", + "!nvcc -V\n", + "# Check GCC version\n", + "!gcc --version\n", + "# Create a new Conda environment\n", + "%conda create -n mmyolo python=3.8 -y\n", + "%conda activate mmyolo\n", + "# If you have GPU\n", + "%conda install pytorch torchvision -c pytorch\n", + "# If you only have CPU\n", + "# %conda install pytorch torchvision cpuonly -c pytorch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check PyTorch version\n", + "import torch\n", + "print(torch.__version__)\n", + "print(torch.cuda.is_available())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Install MMYOLO and dependency libraries using the following commands.\n", + "For details about how to configure the environment, see [Installation and verification](https://mmyolo.readthedocs.io/en/latest/get_started/installation.html).\n", + "```{note}\n", + "Note: Since this repo uses OpenMMLab 2.0, it is better to create a new conda virtual environment to prevent conflicts with the repo installed in OpenMMLab 1.0.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-qATUuntwmfD", + "outputId": "24be577b-efce-46f2-8b2f-a65d02824467" + }, + "outputs": [], + "source": [ + "!git clone https://github.com/open-mmlab/mmyolo.git\n", + "%cd mmyolo\n", + "%pip install -U openmim\n", + "!mim install -r requirements/mminstall.txt\n", + "# Install albumentations\n", + "!mim install -r requirements/albu.txt\n", + "# Install MMYOLO\n", + "!mim install -v -e .\n", + "# \"-v\" means verbose, or more output\n", + "# \"-e\" means installing a project in editable mode,\n", + "# thus any local modifications made to the code will take effect without reinstallation." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset\n", + "\n", + "The Cat dataset is a single-category dataset consisting of 144 pictures (the original pictures are provided by @RangeKing, and cleaned by @PeterH0323), which contains the annotation information required for training. The sample image is shown below:\n", + "\n", + "
\n", + "\"cat\n", + "
\n", + "\n", + "You can download and use it directly by the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gMQXwWuIw3ef", + "outputId": "c8efeac7-5b0c-4342-b5af-d3e790e358c3" + }, + "outputs": [], + "source": [ + "!python tools/misc/download_dataset.py --dataset-name cat --save-dir ./data/cat --unzip --delete" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "covQskXXw2ul" + }, + "source": [ + "This dataset is automatically downloaded to the `./data/cat` dir with the following directory structure:\n", + "\n", + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "The cat dataset is located in the mmyolo project dir, and `data/cat/annotations` stores annotations in COCO format, and `data/cat/images` stores all images\n", + "\n", + "## Config\n", + "\n", + "Taking YOLOv5 algorithm as an example, considering the limited GPU memory of users, we need to modify some default training parameters to make them run smoothly. The key parameters to be modified are as follows:\n", + "\n", + "- YOLOv5 is an Anchor-Based algorithm, and different datasets need to calculate suitable anchors adaptively\n", + "- The default config uses 8 GPUs with a batch size of 16 per GPU. Now change it to a single GPU with a batch size of 12.\n", + "- The default training epoch is 300. Change it to 40 epoch\n", + "- Given the small size of the dataset, we opted to use fixed backbone weights\n", + "- In principle, the learning rate should be linearly scaled accordingly when the batch size is changed, but actual measurements have found that this is not necessary\n", + "\n", + "Create a `yolov5_s-v61_fast_1xb12-40e_cat.py` config file in the `configs/yolov5` folder (we have provided this config for you to use directly) and copy the following into the config file.\n", + "\n", + "```python\n", + "# Inherit and overwrite part of the config based on this config\n", + "_base_ = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py'\n", + "\n", + "data_root = './data/cat/' # dataset root\n", + "class_name = ('cat', ) # dataset category name\n", + "num_classes = len(class_name) # dataset category number\n", + "# metainfo is a configuration that must be passed to the dataloader, otherwise it is invalid\n", + "# palette is a display color for category at visualization\n", + "# The palette length must be greater than or equal to the length of the classes\n", + "metainfo = dict(classes=class_name, palette=[(20, 220, 60)])\n", + "\n", + "# Adaptive anchor based on tools/analysis_tools/optimize_anchors.py\n", + "anchors = [\n", + " [(68, 69), (154, 91), (143, 162)], # P3/8\n", + " [(242, 160), (189, 287), (391, 207)], # P4/16\n", + " [(353, 337), (539, 341), (443, 432)] # P5/32\n", + "]\n", + "# Max training 40 epoch\n", + "max_epochs = 40\n", + "# bs = 12\n", + "train_batch_size_per_gpu = 12\n", + "# dataloader num workers\n", + "train_num_workers = 4\n", + "\n", + "# load COCO pre-trained weight\n", + "load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' # noqa\n", + "\n", + "model = dict(\n", + " # Fixed the weight of the entire backbone without training\n", + " backbone=dict(frozen_stages=4),\n", + " bbox_head=dict(\n", + " head_module=dict(num_classes=num_classes),\n", + " prior_generator=dict(base_sizes=anchors)\n", + " ))\n", + "\n", + "train_dataloader = dict(\n", + " batch_size=train_batch_size_per_gpu,\n", + " num_workers=train_num_workers,\n", + " dataset=dict(\n", + " data_root=data_root,\n", + " metainfo=metainfo,\n", + " # Dataset annotation file of json path\n", + " ann_file='annotations/trainval.json',\n", + " # Dataset prefix\n", + " data_prefix=dict(img='images/')))\n", + "\n", + "val_dataloader = dict(\n", + " dataset=dict(\n", + " metainfo=metainfo,\n", + " data_root=data_root,\n", + " ann_file='annotations/test.json',\n", + " data_prefix=dict(img='images/')))\n", + "\n", + "test_dataloader = val_dataloader\n", + "\n", + "_base_.optim_wrapper.optimizer.batch_size_per_gpu = train_batch_size_per_gpu\n", + "\n", + "val_evaluator = dict(ann_file=data_root + 'annotations/test.json')\n", + "test_evaluator = val_evaluator\n", + "\n", + "default_hooks = dict(\n", + " # Save weights every 10 epochs and a maximum of two weights can be saved.\n", + " # The best model is saved automatically during model evaluation\n", + " checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'),\n", + " # The warmup_mim_iter parameter is critical.\n", + " # The default value is 1000 which is not suitable for cat datasets.\n", + " param_scheduler=dict(max_epochs=max_epochs, warmup_mim_iter=10),\n", + " # The log printing interval is 5\n", + " logger=dict(type='LoggerHook', interval=5))\n", + "# The evaluation interval is 10\n", + "train_cfg = dict(max_epochs=max_epochs, val_interval=10)\n", + "```\n", + "\n", + "The above config is inherited from `yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py`. According to the characteristics of cat dataset updated `data_root`, `metainfo`, `train_dataloader`, `val_dataloader`, `num_classes` and other config.\n", + "\n", + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "TQ0h6sv_rJxq" + }, + "source": [ + "Run the above training command, `work_dirs/yolov5_s-v61_fast_1xb12-40e_cat` folder will be automatically generated, the checkpoint file and the training config file will be saved in this folder. On a low-end 1660 GPU, the entire training process takes about eight minutes.\n", + "\n", + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "The performance on `test.json` is as follows:\n", + "\n", + "```text\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.631\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.909\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.747\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.631\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.627\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.703\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.703\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.703\n", + "```\n", + "\n", + "The above properties are printed via the COCO API, where -1 indicates that no object exists for the scale. According to the rules defined by COCO, the Cat dataset contains all large sized objects, and there are no small or medium-sized objects.\n", + "\n", + "### Some Notes\n", + "\n", + "Two key warnings are printed during training:\n", + "\n", + "- You are using `YOLOv5Head` with num_classes == 1. The loss_cls will be 0. This is a normal phenomenon.\n", + "- The model and loaded state dict do not match exactly\n", + "\n", + "Neither of these warnings will have any impact on performance. The first warning is because the `num_classes` currently trained is 1, the loss of the classification branch is always 0 according to the community of the YOLOv5 algorithm, which is a normal phenomenon. The second warning is because we are currently training in fine-tuning mode, we load the COCO pre-trained weights for 80 classes,\n", + "This will lead to the final Head module convolution channel number does not correspond, resulting in this part of the weight can not be loaded, which is also a normal phenomenon.\n", + "\n", + "### Training is resumed after the interruption\n", + "\n", + "If you stop training, you can add `--resume` to the end of the training command and the program will automatically resume training with the latest weights file from `work_dirs`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py --resume" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "3sJxvQoUrMhX" + }, + "source": [ + "### Save GPU memory strategy\n", + "\n", + "The above config requires about 3G RAM, so if you don't have enough, consider turning on mixed-precision training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py --amp" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "jVJdyHTxrQ9a" + }, + "source": [ + "### Training visualization\n", + "\n", + "MMYOLO currently supports local, TensorBoard, WandB and other back-end visualization. The default is to use local visualization, and you can switch to WandB and other real-time visualization of various indicators in the training process.\n", + "\n", + "#### 1 WandB\n", + "\n", + "WandB visualization need registered in website, and in the https://wandb.ai/settings for wandb API Keys.\n", + "\n", + "
\n", + "\"image\"/\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install wandb\n", + "# After running wandb login, enter the API Keys obtained above, and the login is successful.\n", + "!wandb login" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "Yu0_4YYRrbyY" + }, + "source": [ + "Add the wandb config at the end of config file we just created: `configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py`.\n", + "\n", + "```python\n", + "visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')])\n", + "```\n", + "\n", + "Running the training command and you will see the loss, learning rate, and coco/bbox_mAP visualizations in the link." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "f_DyzfDIzwMa" + }, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "#### 2 Tensorboard\n", + "\n", + "Install Tensorboard using the following command." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "gHkGlii3n29Q" + }, + "outputs": [], + "source": [ + "%pip install tensorboard" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "bE-nx9TY1P-M" + }, + "source": [ + "Add the `tensorboard` config at the end of config file we just created: `configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py`.\n", + "\n", + "```python\n", + "visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')])\n", + "```\n", + "\n", + "After re-running the training command, Tensorboard file will be generated in the visualization folder `work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/{timestamp}/vis_data`.\n", + "We can use Tensorboard to view the loss, learning rate, and coco/bbox_mAP visualizations from a web link by running the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "g8fZgokho5CE" + }, + "outputs": [], + "source": [ + "!tensorboard --logdir=work_dirs/yolov5_s-v61_fast_1xb12-40e_cat" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "GUZ7MPoaro-o" + }, + "source": [ + "## Testing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VYmxtE0GunTB", + "outputId": "f440807c-1931-4810-b76d-617f73fde227" + }, + "outputs": [], + "source": [ + "!python tools/test.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --show-dir show_results" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "_cFocUqN0BCb" + }, + "source": [ + "Run the above test command, you can not only get the AP performance printed in the **Training** section, You can also automatically save the result images to the `work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/{timestamp}/show_results` folder. Below is one of the result images, the left image is the actual annotation, and the right image is the inference result of the model.\n", + "\n", + "
\n", + "\"result_img\"/\n", + "
\n", + "\n", + "You can also visualize model inference results in a browser window if you use 'WandbVisBackend' or 'TensorboardVisBackend'.\n", + "\n", + "## Feature map visualization\n", + "\n", + "MMYOLO provides visualization scripts for feature map to analyze the current model training. Please refer to [Feature Map Visualization](../recommended_topics/visualization.md)\n", + "\n", + "Due to the bias of direct visualization of `test_pipeline`, we need modify the `test_pipeline` of `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py`,\n", + "\n", + "```python\n", + "test_pipeline = [\n", + " dict(\n", + " type='LoadImageFromFile',\n", + " file_client_args=_base_.file_client_args),\n", + " dict(type='YOLOv5KeepRatioResize', scale=img_scale),\n", + " dict(\n", + " type='LetterResize',\n", + " scale=img_scale,\n", + " allow_scale_up=False,\n", + " pad_val=dict(img=114)),\n", + " dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'),\n", + " dict(\n", + " type='mmdet.PackDetInputs',\n", + " meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n", + " 'scale_factor', 'pad_param'))\n", + "]\n", + "```\n", + "\n", + "to the following config:\n", + "\n", + "```python\n", + "test_pipeline = [\n", + " dict(\n", + " type='LoadImageFromFile',\n", + " file_client_args=_base_.file_client_args),\n", + " dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # modify the LetterResize to mmdet.Resize\n", + " dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'),\n", + " dict(\n", + " type='mmdet.PackDetInputs',\n", + " meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n", + " 'scale_factor'))\n", + "]\n", + "```\n", + "\n", + "Let's choose the `data/cat/images/IMG_20221020_112705.jpg` image as an example to visualize the output feature maps of YOLOv5 backbone and neck layers.\n", + "\n", + "**1. Visualize the three channels of YOLOv5 backbone**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python demo/featmap_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --target-layers backbone \\\n", + " --channel-reduction squeeze_mean" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "The result will be saved to the output folder in current path. Three output feature maps plotted in the above figure correspond to small, medium and large output feature maps. As the backbone of this training is not actually involved in training, it can be seen from the above figure that the big object cat is predicted on the small feature map, which is in line with the idea of hierarchical detection of object detection.\n", + "\n", + "**2. Visualize the three channels of YOLOv5 neck**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python demo/featmap_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --target-layers neck \\\n", + " --channel-reduction squeeze_mean" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "As can be seen from the above figure, because neck is involved in training, and we also reset anchor, the three output feature maps are forced to simulate the same scale object, resulting in the three output maps of neck are similar, which destroys the original pre-training distribution of backbone. At the same time, it can also be seen that 40 epochs are not enough to train the above dataset, and the feature maps do not perform well.\n", + "\n", + "**3. Grad-Based CAM visualization**\n", + "\n", + "Based on the above feature map visualization, we can analyze Grad CAM at the feature layer of bbox level.\n", + "\n", + "Install `grad-cam` package:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install \"grad-cam\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(a) View Grad CAM of the minimum output feature map of the neck" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python demo/boxam_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --target-layer neck.out_layers[2]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "9v-dMkePvHMg" + }, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "(b) View Grad CAM of the medium output feature map of the neck" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p9H9u0A-3KAD", + "outputId": "32ca5a56-052f-4930-f53c-41cc3a9dc619" + }, + "outputs": [], + "source": [ + "!python demo/boxam_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --target-layer neck.out_layers[1]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(c) View Grad CAM of the maximum output feature map of the neck" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MrKan1U43uUY", + "outputId": "690f8414-a76b-4fa6-e600-7cc874ce1914" + }, + "outputs": [], + "source": [ + "!python demo/boxam_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --target-layer neck.out_layers[0]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "## EasyDeploy deployment\n", + "\n", + "Here we'll use MMYOLO's [EasyDeploy](../../../projects/easydeploy/) to demonstrate the transformation deployment and basic inference of model.\n", + "\n", + "First you need to follow EasyDeploy's [basic documentation](../../../projects/easydeploy/docs/model_convert.md) controls own equipment installed for each library.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install onnx\n", + "%pip install onnx-simplifier # Install if you want to use simplify\n", + "%pip install tensorrt # If you have GPU environment and need to output TensorRT model you need to continue execution" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once installed, you can use the following command to transform and deploy the trained model on the cat dataset with one click. The current ONNX version is 1.13.0 and TensorRT version is 8.5.3.1, so keep the `--opset` value of 11. The remaining parameters need to be adjusted according to the config used. Here we export the CPU version of ONNX with the `--backend` set to 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 534 + }, + "id": "YsRFEecU5C0w", + "outputId": "c26011d4-2836-4715-cd6b-68836294db33" + }, + "outputs": [], + "source": [ + "!python projects/easydeploy/tools/export.py \\\n", + "\t configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + "\t work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + "\t --work-dir work_dirs/yolov5_s-v61_fast_1xb12-40e_cat \\\n", + " --img-size 640 640 \\\n", + " --batch 1 \\\n", + " --device cpu \\\n", + " --simplify \\\n", + "\t --opset 11 \\\n", + "\t --backend 1 \\\n", + "\t --pre-topk 1000 \\\n", + "\t --keep-topk 100 \\\n", + "\t --iou-threshold 0.65 \\\n", + "\t --score-threshold 0.25\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "q1EY415x3Idx" + }, + "source": [ + "On success, you will get the converted ONNX model under `work-dir`, which is named `end2end.onnx` by default.\n", + "\n", + "Let's use `end2end.onnx` model to perform a basic image inference:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python projects/easydeploy/tools/image-demo.py \\\n", + " data/cat/images/IMG_20210728_205312.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/end2end.onnx \\\n", + " --device cpu" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "IrjiBa5YwDQM" + }, + "source": [ + "After successful inference, the result image will be generated in the `output` folder of the default MMYOLO root directory. If you want to see the result without saving it, you can add `--show` to the end of the above command. For convenience, the following is the generated result.\n", + "\n", + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "Let's go on to convert the engine file for TensorRT, because TensorRT needs to be specific to the current environment and deployment version, so make sure to export the parameters, here we export the TensorRT8 file, the `--backend` is 2." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d8zxczqiBLoB" + }, + "outputs": [], + "source": [ + "!python projects/easydeploy/tools/export.py \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \\\n", + " --work-dir work_dirs/yolov5_s-v61_fast_1xb12-40e_cat \\\n", + " --img-size 640 640 \\\n", + " --batch 1 \\\n", + " --device cuda:0 \\\n", + " --simplify \\\n", + " --opset 11 \\\n", + " --backend 2 \\\n", + " --pre-topk 1000 \\\n", + " --keep-topk 100 \\\n", + " --iou-threshold 0.65 \\\n", + " --score-threshold 0.25" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `end2end.onnx` is the ONNX file for the TensorRT8 deployment, which we will use to complete the TensorRT engine transformation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "QFh8rIsX_kVw", + "outputId": "c5bd6929-03a8-400e-be1e-581f32b23f61" + }, + "outputs": [], + "source": [ + "!python projects/easydeploy/tools/build_engine.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/end2end.onnx \\\n", + " --img-size 640 640 \\\n", + " --device cuda:0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Successful execution will generate the `end2end.engine` file under `work-dir`:\n", + "\n", + "```shell\n", + "work_dirs/yolov5_s-v61_fast_1xb12-40e_cat\n", + "├── 202302XX_XXXXXX\n", + "│ ├── 202302XX_XXXXXX.log\n", + "│ └── vis_data\n", + "│ ├── 202302XX_XXXXXX.json\n", + "│ ├── config.py\n", + "│ └── scalars.json\n", + "├── best_coco\n", + "│ └── bbox_mAP_epoch_40.pth\n", + "├── end2end.engine\n", + "├── end2end.onnx\n", + "├── epoch_30.pth\n", + "├── epoch_40.pth\n", + "├── last_checkpoint\n", + "└── yolov5_s-v61_fast_1xb12-40e_cat.py\n", + "```\n", + "\n", + "Let's continue use `image-demo.py` for image inference:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "rOqXEi-jAI7Y", + "outputId": "2a21aaaa-d4ba-498a-f985-2a6a2b8d348f" + }, + "outputs": [], + "source": [ + "!python projects/easydeploy/tools/image-demo.py \\\n", + " data/cat/images/IMG_20210728_205312.jpg \\\n", + " configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \\\n", + " work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/end2end.engine \\\n", + " --device cuda:0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "ocHGUUEA_TjI" + }, + "source": [ + "
\n", + "\"image\"/\n", + "
\n", + "\n", + "This completes the transformation deployment of the trained model and checks the inference results. This is the end of the tutorial.\n", + "\n", + "If you encounter problems during training or testing, please check the [common troubleshooting steps](https://mmyolo.readthedocs.io/en/dev/recommended_topics/troubleshooting_steps.html) first and feel free to open an [issue](https://github.com/open-mmlab/mmyolo/issues/new/choose) if you still can't solve it.\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [], + "toc_visible": true + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/boxam_vis_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/boxam_vis_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..278574f89fe5427cb5be7b9a7fd99f70de090bd4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/boxam_vis_demo.py @@ -0,0 +1,276 @@ +# Copyright (c) OpenMMLab. All rights reserved. +"""This script is in the experimental verification stage and cannot be +guaranteed to be completely correct. Currently Grad-based CAM and Grad-free CAM +are supported. + +The target detection task is different from the classification task. It not +only includes the AM map of the category, but also includes information such as +bbox and mask, so this script is named bboxam. +""" + +import argparse +import os.path +import warnings +from functools import partial + +import cv2 +import mmcv +from mmengine import Config, DictAction, MessageHub +from mmengine.utils import ProgressBar + +try: + from pytorch_grad_cam import AblationCAM, EigenCAM +except ImportError: + raise ImportError('Please run `pip install "grad-cam"` to install ' + 'pytorch_grad_cam package.') + +from mmyolo.utils.boxam_utils import (BoxAMDetectorVisualizer, + BoxAMDetectorWrapper, DetAblationLayer, + DetBoxScoreTarget, GradCAM, + GradCAMPlusPlus, reshape_transform) +from mmyolo.utils.misc import get_file_list + +GRAD_FREE_METHOD_MAP = { + 'ablationcam': AblationCAM, + 'eigencam': EigenCAM, + # 'scorecam': ScoreCAM, # consumes too much memory +} + +GRAD_BASED_METHOD_MAP = {'gradcam': GradCAM, 'gradcam++': GradCAMPlusPlus} + +ALL_SUPPORT_METHODS = list(GRAD_FREE_METHOD_MAP.keys() + | GRAD_BASED_METHOD_MAP.keys()) + +IGNORE_LOSS_PARAMS = { + 'yolov5': ['loss_obj'], + 'yolov6': ['loss_cls'], + 'yolox': ['loss_obj'], + 'rtmdet': ['loss_cls'], + 'yolov7': ['loss_obj'], + 'yolov8': ['loss_cls'], + 'ppyoloe': ['loss_cls'], +} + +# This parameter is required in some algorithms +# for calculating Loss +message_hub = MessageHub.get_current_instance() +message_hub.runtime_info['epoch'] = 0 + + +def parse_args(): + parser = argparse.ArgumentParser(description='Visualize Box AM') + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--method', + default='gradcam', + choices=ALL_SUPPORT_METHODS, + help='Type of method to use, supports ' + f'{", ".join(ALL_SUPPORT_METHODS)}.') + parser.add_argument( + '--target-layers', + default=['neck.out_layers[2]'], + nargs='+', + type=str, + help='The target layers to get Box AM, if not set, the tool will ' + 'specify the neck.out_layers[2]') + parser.add_argument( + '--out-dir', default='./output', help='Path to output file') + parser.add_argument( + '--show', action='store_true', help='Show the CAM results') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + parser.add_argument( + '--topk', + type=int, + default=-1, + help='Select topk predict resutls to show. -1 are mean all.') + parser.add_argument( + '--max-shape', + nargs='+', + type=int, + default=-1, + help='max shapes. Its purpose is to save GPU memory. ' + 'The activation map is scaled and then evaluated. ' + 'If set to -1, it means no scaling.') + parser.add_argument( + '--preview-model', + default=False, + action='store_true', + help='To preview all the model layers') + parser.add_argument( + '--norm-in-bbox', action='store_true', help='Norm in bbox of am image') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + # Only used by AblationCAM + parser.add_argument( + '--batch-size', + type=int, + default=1, + help='batch of inference of AblationCAM') + parser.add_argument( + '--ratio-channels-to-ablate', + type=int, + default=0.5, + help='Making it much faster of AblationCAM. ' + 'The parameter controls how many channels should be ablated') + + args = parser.parse_args() + return args + + +def init_detector_and_visualizer(args, cfg): + max_shape = args.max_shape + if not isinstance(max_shape, list): + max_shape = [args.max_shape] + assert len(max_shape) == 1 or len(max_shape) == 2 + + model_wrapper = BoxAMDetectorWrapper( + cfg, args.checkpoint, args.score_thr, device=args.device) + + if args.preview_model: + print(model_wrapper.detector) + print('\n Please remove `--preview-model` to get the BoxAM.') + return None, None + + target_layers = [] + for target_layer in args.target_layers: + try: + target_layers.append( + eval(f'model_wrapper.detector.{target_layer}')) + except Exception as e: + print(model_wrapper.detector) + raise RuntimeError('layer does not exist', e) + + ablationcam_extra_params = { + 'batch_size': args.batch_size, + 'ablation_layer': DetAblationLayer(), + 'ratio_channels_to_ablate': args.ratio_channels_to_ablate + } + + if args.method in GRAD_BASED_METHOD_MAP: + method_class = GRAD_BASED_METHOD_MAP[args.method] + is_need_grad = True + else: + method_class = GRAD_FREE_METHOD_MAP[args.method] + is_need_grad = False + + boxam_detector_visualizer = BoxAMDetectorVisualizer( + method_class, + model_wrapper, + target_layers, + reshape_transform=partial( + reshape_transform, max_shape=max_shape, is_need_grad=is_need_grad), + is_need_grad=is_need_grad, + extra_params=ablationcam_extra_params) + return model_wrapper, boxam_detector_visualizer + + +def main(): + args = parse_args() + + # hard code + ignore_loss_params = None + for param_keys in IGNORE_LOSS_PARAMS: + if param_keys in args.config: + print(f'The algorithm currently used is {param_keys}') + ignore_loss_params = IGNORE_LOSS_PARAMS[param_keys] + break + + cfg = Config.fromfile(args.config) + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + if not os.path.exists(args.out_dir) and not args.show: + os.mkdir(args.out_dir) + + model_wrapper, boxam_detector_visualizer = init_detector_and_visualizer( + args, cfg) + + # get file list + image_list, source_type = get_file_list(args.img) + + progress_bar = ProgressBar(len(image_list)) + + for image_path in image_list: + image = cv2.imread(image_path) + model_wrapper.set_input_data(image) + + # forward detection results + result = model_wrapper()[0] + + pred_instances = result.pred_instances + # Get candidate predict info with score threshold + pred_instances = pred_instances[pred_instances.scores > args.score_thr] + + if len(pred_instances) == 0: + warnings.warn('empty detection results! skip this') + continue + + if args.topk > 0: + pred_instances = pred_instances[:args.topk] + + targets = [ + DetBoxScoreTarget( + pred_instances, + device=args.device, + ignore_loss_params=ignore_loss_params) + ] + + if args.method in GRAD_BASED_METHOD_MAP: + model_wrapper.need_loss(True) + model_wrapper.set_input_data(image, pred_instances) + boxam_detector_visualizer.switch_activations_and_grads( + model_wrapper) + + # get box am image + grayscale_boxam = boxam_detector_visualizer(image, targets=targets) + + # draw cam on image + pred_instances = pred_instances.numpy() + image_with_bounding_boxes = boxam_detector_visualizer.show_am( + image, + pred_instances, + grayscale_boxam, + with_norm_in_bboxes=args.norm_in_bbox) + + if source_type['is_dir']: + filename = os.path.relpath(image_path, args.img).replace('/', '_') + else: + filename = os.path.basename(image_path) + out_file = None if args.show else os.path.join(args.out_dir, filename) + + if out_file: + mmcv.imwrite(image_with_bounding_boxes, out_file) + else: + cv2.namedWindow(filename, 0) + cv2.imshow(filename, image_with_bounding_boxes) + cv2.waitKey(0) + + # switch + if args.method in GRAD_BASED_METHOD_MAP: + model_wrapper.need_loss(False) + boxam_detector_visualizer.switch_activations_and_grads( + model_wrapper) + + progress_bar.update() + + if not args.show: + print(f'All done!' + f'\nResults have been saved at {os.path.abspath(args.out_dir)}') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/demo.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/demo.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f390fc9013dc8fa76a305b8e56d2bec76ff758e9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/demo.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e9ab135da7eacabdeeeee11ba4b7bcdd1bfac128cf92a9de9c79f984060ae1e +size 259865 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/deploy_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/deploy_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..f5d08df47fc9740bc1d2ca837d5188f8b4eac267 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/deploy_demo.py @@ -0,0 +1,120 @@ +# Copyright (c) OpenMMLab. All rights reserved. +"""Deploy demo for mmdeploy. + +This script help user to run mmdeploy demo after convert the +checkpoint to backends. + +Usage: + python deploy_demo.py img \ + config \ + checkpoint \ + [--deploy-cfg DEPLOY_CFG] \ + [--device DEVICE] \ + [--out-dir OUT_DIR] \ + [--show] \ + [--score-thr SCORE_THR] + +Example: + python deploy_demo.py \ + ${MMYOLO_PATH}/data/cat/images \ + ./yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py \ + ./end2end.engine \ + --deploy-cfg ./detection_tensorrt-fp16_dynamic-192x192-960x960.py \ + --out-dir ${MMYOLO_PATH}/work_dirs/deploy_predict_out \ + --device cuda:0 \ + --score-thr 0.5 +""" +import argparse +import os + +import torch +from mmengine import ProgressBar + +from mmyolo.utils.misc import get_file_list + +try: + from mmdeploy.apis.utils import build_task_processor + from mmdeploy.utils import get_input_shape, load_config +except ImportError: + raise ImportError( + 'mmdeploy is not installed, please see ' + 'https://mmdeploy.readthedocs.io/en/1.x/01-how-to-build/build_from_source.html' # noqa + ) + + +def parse_args(): + parser = argparse.ArgumentParser(description='For mmdeploy predict') + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('config', help='model config root') + parser.add_argument('checkpoint', help='checkpoint backend model path') + parser.add_argument('--deploy-cfg', help='deploy config path') + parser.add_argument( + '--device', default='cuda:0', help='device used for conversion') + parser.add_argument( + '--out-dir', default='./output', help='Path to output file') + parser.add_argument( + '--show', action='store_true', help='Show the detection results') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + args = parser.parse_args() + return args + + +# TODO Still need to refactor to not building dataset. +def main(): + args = parse_args() + + if not os.path.exists(args.out_dir) and not args.show: + os.mkdir(args.out_dir) + + # read deploy_cfg and config + deploy_cfg, model_cfg = load_config(args.deploy_cfg, args.config) + + # build task and backend model + task_processor = build_task_processor(model_cfg, deploy_cfg, args.device) + model = task_processor.build_backend_model([args.checkpoint]) + + # get model input shape + input_shape = get_input_shape(deploy_cfg) + + # get file list + files, source_type = get_file_list(args.img) + + # start detector inference + progress_bar = ProgressBar(len(files)) + for file in files: + # process input image + model_inputs, _ = task_processor.create_input(file, input_shape) + + # do model inference + with torch.no_grad(): + result = model.test_step(model_inputs) + + if source_type['is_dir']: + filename = os.path.relpath(file, args.img).replace('/', '_') + else: + filename = os.path.basename(file) + out_file = None if args.show else os.path.join(args.out_dir, filename) + + # filter score + result = result[0] + result.pred_instances = result.pred_instances[ + result.pred_instances.scores > args.score_thr] + + # visualize results + task_processor.visualize( + image=file, + model=model, + result=result, + show_result=args.show, + window_name=os.path.basename(filename), + output_file=out_file) + + progress_bar.update() + + print('All done!') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/dog.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/dog.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b37071c4b38a5112c700e7a3d46ebb351d9b494 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/dog.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5a9522051c3cec2bbd2f6323fccba32e8fbf3ddcc2b3e2fd46b04c720bc6f866 +size 163759 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/featmap_vis_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/featmap_vis_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..892e73d616b0e629ddfcc276e8eb4ca289f5085b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/featmap_vis_demo.py @@ -0,0 +1,199 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import os +from typing import Sequence + +import mmcv +from mmdet.apis import inference_detector, init_detector +from mmengine import Config, DictAction +from mmengine.registry import init_default_scope +from mmengine.utils import ProgressBar + +from mmyolo.registry import VISUALIZERS +from mmyolo.utils.misc import auto_arrange_images, get_file_list + + +def parse_args(): + parser = argparse.ArgumentParser(description='Visualize feature map') + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--out-dir', default='./output', help='Path to output file') + parser.add_argument( + '--target-layers', + default=['backbone'], + nargs='+', + type=str, + help='The target layers to get feature map, if not set, the tool will ' + 'specify the backbone') + parser.add_argument( + '--preview-model', + default=False, + action='store_true', + help='To preview all the model layers') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + parser.add_argument( + '--show', action='store_true', help='Show the featmap results') + parser.add_argument( + '--channel-reduction', + default='select_max', + help='Reduce multiple channels to a single channel') + parser.add_argument( + '--topk', + type=int, + default=4, + help='Select topk channel to show by the sum of each channel') + parser.add_argument( + '--arrangement', + nargs='+', + type=int, + default=[2, 2], + help='The arrangement of featmap when channel_reduction is ' + 'not None and topk > 0') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + args = parser.parse_args() + return args + + +class ActivationsWrapper: + + def __init__(self, model, target_layers): + self.model = model + self.activations = [] + self.handles = [] + self.image = None + for target_layer in target_layers: + self.handles.append( + target_layer.register_forward_hook(self.save_activation)) + + def save_activation(self, module, input, output): + self.activations.append(output) + + def __call__(self, img_path): + self.activations = [] + results = inference_detector(self.model, img_path) + return results, self.activations + + def release(self): + for handle in self.handles: + handle.remove() + + +def main(): + args = parse_args() + + cfg = Config.fromfile(args.config) + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + init_default_scope(cfg.get('default_scope', 'mmyolo')) + + channel_reduction = args.channel_reduction + if channel_reduction == 'None': + channel_reduction = None + assert len(args.arrangement) == 2 + + model = init_detector(args.config, args.checkpoint, device=args.device) + + if not os.path.exists(args.out_dir) and not args.show: + os.mkdir(args.out_dir) + + if args.preview_model: + print(model) + print('\n This flag is only show model, if you want to continue, ' + 'please remove `--preview-model` to get the feature map.') + return + + target_layers = [] + for target_layer in args.target_layers: + try: + target_layers.append(eval(f'model.{target_layer}')) + except Exception as e: + print(model) + raise RuntimeError('layer does not exist', e) + + activations_wrapper = ActivationsWrapper(model, target_layers) + + # init visualizer + visualizer = VISUALIZERS.build(model.cfg.visualizer) + visualizer.dataset_meta = model.dataset_meta + + # get file list + image_list, source_type = get_file_list(args.img) + + progress_bar = ProgressBar(len(image_list)) + for image_path in image_list: + result, featmaps = activations_wrapper(image_path) + if not isinstance(featmaps, Sequence): + featmaps = [featmaps] + + flatten_featmaps = [] + for featmap in featmaps: + if isinstance(featmap, Sequence): + flatten_featmaps.extend(featmap) + else: + flatten_featmaps.append(featmap) + + img = mmcv.imread(image_path) + img = mmcv.imconvert(img, 'bgr', 'rgb') + + if source_type['is_dir']: + filename = os.path.relpath(image_path, args.img).replace('/', '_') + else: + filename = os.path.basename(image_path) + out_file = None if args.show else os.path.join(args.out_dir, filename) + + # show the results + shown_imgs = [] + visualizer.add_datasample( + 'result', + img, + data_sample=result, + draw_gt=False, + show=False, + wait_time=0, + out_file=None, + pred_score_thr=args.score_thr) + drawn_img = visualizer.get_image() + + for featmap in flatten_featmaps: + shown_img = visualizer.draw_featmap( + featmap[0], + drawn_img, + channel_reduction=channel_reduction, + topk=args.topk, + arrangement=args.arrangement) + shown_imgs.append(shown_img) + + shown_imgs = auto_arrange_images(shown_imgs) + + progress_bar.update() + if out_file: + mmcv.imwrite(shown_imgs[..., ::-1], out_file) + + if args.show: + visualizer.show(shown_imgs) + + if not args.show: + print(f'All done!' + f'\nResults have been saved at {os.path.abspath(args.out_dir)}') + + +# Please refer to the usage tutorial: +# https://github.com/open-mmlab/mmyolo/blob/main/docs/zh_cn/user_guides/visualization.md # noqa +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/image_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/image_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..fa2cfb2a03f7e8328dd068851433d69c9f4a0db5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/image_demo.py @@ -0,0 +1,168 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import os +from argparse import ArgumentParser +from pathlib import Path + +import mmcv +from mmdet.apis import inference_detector, init_detector +from mmengine.config import Config, ConfigDict +from mmengine.logging import print_log +from mmengine.utils import ProgressBar, path + +from mmyolo.registry import VISUALIZERS +from mmyolo.utils import switch_to_deploy +from mmyolo.utils.labelme_utils import LabelmeFormat +from mmyolo.utils.misc import get_file_list, show_data_classes + + +def parse_args(): + parser = ArgumentParser() + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--out-dir', default='./output', help='Path to output file') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--show', action='store_true', help='Show the detection results') + parser.add_argument( + '--deploy', + action='store_true', + help='Switch model to deployment mode') + parser.add_argument( + '--tta', + action='store_true', + help='Whether to use test time augmentation') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + parser.add_argument( + '--class-name', + nargs='+', + type=str, + help='Only Save those classes if set') + parser.add_argument( + '--to-labelme', + action='store_true', + help='Output labelme style label file') + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + + if args.to_labelme and args.show: + raise RuntimeError('`--to-labelme` or `--show` only ' + 'can choose one at the same time.') + config = args.config + + if isinstance(config, (str, Path)): + config = Config.fromfile(config) + elif not isinstance(config, Config): + raise TypeError('config must be a filename or Config object, ' + f'but got {type(config)}') + if 'init_cfg' in config.model.backbone: + config.model.backbone.init_cfg = None + + if args.tta: + assert 'tta_model' in config, 'Cannot find ``tta_model`` in config.' \ + " Can't use tta !" + assert 'tta_pipeline' in config, 'Cannot find ``tta_pipeline`` ' \ + "in config. Can't use tta !" + config.model = ConfigDict(**config.tta_model, module=config.model) + test_data_cfg = config.test_dataloader.dataset + while 'dataset' in test_data_cfg: + test_data_cfg = test_data_cfg['dataset'] + + # batch_shapes_cfg will force control the size of the output image, + # it is not compatible with tta. + if 'batch_shapes_cfg' in test_data_cfg: + test_data_cfg.batch_shapes_cfg = None + test_data_cfg.pipeline = config.tta_pipeline + + # TODO: TTA mode will error if cfg_options is not set. + # This is an mmdet issue and needs to be fixed later. + # build the model from a config file and a checkpoint file + model = init_detector( + config, args.checkpoint, device=args.device, cfg_options={}) + + if args.deploy: + switch_to_deploy(model) + + if not args.show: + path.mkdir_or_exist(args.out_dir) + + # init visualizer + visualizer = VISUALIZERS.build(model.cfg.visualizer) + visualizer.dataset_meta = model.dataset_meta + + # get file list + files, source_type = get_file_list(args.img) + + # get model class name + dataset_classes = model.dataset_meta.get('classes') + + # ready for labelme format if it is needed + to_label_format = LabelmeFormat(classes=dataset_classes) + + # check class name + if args.class_name is not None: + for class_name in args.class_name: + if class_name in dataset_classes: + continue + show_data_classes(dataset_classes) + raise RuntimeError( + 'Expected args.class_name to be one of the list, ' + f'but got "{class_name}"') + + # start detector inference + progress_bar = ProgressBar(len(files)) + for file in files: + result = inference_detector(model, file) + + img = mmcv.imread(file) + img = mmcv.imconvert(img, 'bgr', 'rgb') + + if source_type['is_dir']: + filename = os.path.relpath(file, args.img).replace('/', '_') + else: + filename = os.path.basename(file) + out_file = None if args.show else os.path.join(args.out_dir, filename) + + progress_bar.update() + + # Get candidate predict info with score threshold + pred_instances = result.pred_instances[ + result.pred_instances.scores > args.score_thr] + + if args.to_labelme: + # save result to labelme files + out_file = out_file.replace( + os.path.splitext(out_file)[-1], '.json') + to_label_format(pred_instances, result.metainfo, out_file, + args.class_name) + continue + + visualizer.add_datasample( + filename, + img, + data_sample=result, + draw_gt=False, + show=args.show, + wait_time=0, + out_file=out_file, + pred_score_thr=args.score_thr) + + if not args.show and not args.to_labelme: + print_log( + f'\nResults have been saved at {os.path.abspath(args.out_dir)}') + + elif args.to_labelme: + print_log('\nLabelme format label files ' + f'had all been saved in {args.out_dir}') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/large_image.jpg b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/large_image.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77707afa830e89b5d708266fc7dfa9a21de66139 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/large_image.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5bc4c4d3e89e7cddaa6493f2ff5f08e889186a89cbef27c8e1962e0cae9509e2 +size 171829 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/large_image_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/large_image_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..bdbc3a56d0056c3965fac28c49e18b31355a2029 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/large_image_demo.py @@ -0,0 +1,294 @@ +# Copyright (c) OpenMMLab. All rights reserved. +"""Perform MMYOLO inference on large images (as satellite imagery) as: + +```shell +wget -P checkpoint https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth # noqa: E501, E261. + +python demo/large_image_demo.py \ + demo/large_image.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + checkpoint/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth +``` +""" + +import os +import random +from argparse import ArgumentParser +from pathlib import Path + +import mmcv +import numpy as np +from mmdet.apis import inference_detector, init_detector +from mmengine.config import Config, ConfigDict +from mmengine.logging import print_log +from mmengine.utils import ProgressBar + +try: + from sahi.slicing import slice_image +except ImportError: + raise ImportError('Please run "pip install -U sahi" ' + 'to install sahi first for large image inference.') + +from mmyolo.registry import VISUALIZERS +from mmyolo.utils import switch_to_deploy +from mmyolo.utils.large_image import merge_results_by_nms, shift_predictions +from mmyolo.utils.misc import get_file_list + + +def parse_args(): + parser = ArgumentParser( + description='Perform MMYOLO inference on large images.') + parser.add_argument( + 'img', help='Image path, include image file, dir and URL.') + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--out-dir', default='./output', help='Path to output file') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--show', action='store_true', help='Show the detection results') + parser.add_argument( + '--deploy', + action='store_true', + help='Switch model to deployment mode') + parser.add_argument( + '--tta', + action='store_true', + help='Whether to use test time augmentation') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + parser.add_argument( + '--patch-size', type=int, default=640, help='The size of patches') + parser.add_argument( + '--patch-overlap-ratio', + type=float, + default=0.25, + help='Ratio of overlap between two patches') + parser.add_argument( + '--merge-iou-thr', + type=float, + default=0.25, + help='IoU threshould for merging results') + parser.add_argument( + '--merge-nms-type', + type=str, + default='nms', + help='NMS type for merging results') + parser.add_argument( + '--batch-size', + type=int, + default=1, + help='Batch size, must greater than or equal to 1') + parser.add_argument( + '--debug', + action='store_true', + help='Export debug results before merging') + parser.add_argument( + '--save-patch', + action='store_true', + help='Save the results of each patch. ' + 'The `--debug` must be enabled.') + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + + config = args.config + + if isinstance(config, (str, Path)): + config = Config.fromfile(config) + elif not isinstance(config, Config): + raise TypeError('config must be a filename or Config object, ' + f'but got {type(config)}') + if 'init_cfg' in config.model.backbone: + config.model.backbone.init_cfg = None + + if args.tta: + assert 'tta_model' in config, 'Cannot find ``tta_model`` in config.' \ + " Can't use tta !" + assert 'tta_pipeline' in config, 'Cannot find ``tta_pipeline`` ' \ + "in config. Can't use tta !" + config.model = ConfigDict(**config.tta_model, module=config.model) + test_data_cfg = config.test_dataloader.dataset + while 'dataset' in test_data_cfg: + test_data_cfg = test_data_cfg['dataset'] + + # batch_shapes_cfg will force control the size of the output image, + # it is not compatible with tta. + if 'batch_shapes_cfg' in test_data_cfg: + test_data_cfg.batch_shapes_cfg = None + test_data_cfg.pipeline = config.tta_pipeline + + # TODO: TTA mode will error if cfg_options is not set. + # This is an mmdet issue and needs to be fixed later. + # build the model from a config file and a checkpoint file + model = init_detector( + config, args.checkpoint, device=args.device, cfg_options={}) + + if args.deploy: + switch_to_deploy(model) + + if not os.path.exists(args.out_dir) and not args.show: + os.mkdir(args.out_dir) + + # init visualizer + visualizer = VISUALIZERS.build(model.cfg.visualizer) + visualizer.dataset_meta = model.dataset_meta + + # get file list + files, source_type = get_file_list(args.img) + + # start detector inference + print(f'Performing inference on {len(files)} images.... ' + 'This may take a while.') + progress_bar = ProgressBar(len(files)) + for file in files: + # read image + img = mmcv.imread(file) + + # arrange slices + height, width = img.shape[:2] + sliced_image_object = slice_image( + img, + slice_height=args.patch_size, + slice_width=args.patch_size, + auto_slice_resolution=False, + overlap_height_ratio=args.patch_overlap_ratio, + overlap_width_ratio=args.patch_overlap_ratio, + ) + + # perform sliced inference + slice_results = [] + start = 0 + while True: + # prepare batch slices + end = min(start + args.batch_size, len(sliced_image_object)) + images = [] + for sliced_image in sliced_image_object.images[start:end]: + images.append(sliced_image) + + # forward the model + slice_results.extend(inference_detector(model, images)) + + if end >= len(sliced_image_object): + break + start += args.batch_size + + if source_type['is_dir']: + filename = os.path.relpath(file, args.img).replace('/', '_') + else: + filename = os.path.basename(file) + + img = mmcv.imconvert(img, 'bgr', 'rgb') + out_file = None if args.show else os.path.join(args.out_dir, filename) + + # export debug images + if args.debug: + # export sliced image results + name, suffix = os.path.splitext(filename) + + shifted_instances = shift_predictions( + slice_results, + sliced_image_object.starting_pixels, + src_image_shape=(height, width)) + merged_result = slice_results[0].clone() + merged_result.pred_instances = shifted_instances + + debug_file_name = name + '_debug' + suffix + debug_out_file = None if args.show else os.path.join( + args.out_dir, debug_file_name) + visualizer.set_image(img.copy()) + + debug_grids = [] + for starting_point in sliced_image_object.starting_pixels: + start_point_x = starting_point[0] + start_point_y = starting_point[1] + end_point_x = start_point_x + args.patch_size + end_point_y = start_point_y + args.patch_size + debug_grids.append( + [start_point_x, start_point_y, end_point_x, end_point_y]) + debug_grids = np.array(debug_grids) + debug_grids[:, 0::2] = np.clip(debug_grids[:, 0::2], 1, + img.shape[1] - 1) + debug_grids[:, 1::2] = np.clip(debug_grids[:, 1::2], 1, + img.shape[0] - 1) + + palette = np.random.randint(0, 256, size=(len(debug_grids), 3)) + palette = [tuple(c) for c in palette] + line_styles = random.choices(['-', '-.', ':'], k=len(debug_grids)) + visualizer.draw_bboxes( + debug_grids, + edge_colors=palette, + alpha=1, + line_styles=line_styles) + visualizer.draw_bboxes( + debug_grids, face_colors=palette, alpha=0.15) + + visualizer.draw_texts( + list(range(len(debug_grids))), + debug_grids[:, :2] + 5, + colors='w') + + visualizer.add_datasample( + debug_file_name, + visualizer.get_image(), + data_sample=merged_result, + draw_gt=False, + show=args.show, + wait_time=0, + out_file=debug_out_file, + pred_score_thr=args.score_thr, + ) + + if args.save_patch: + debug_patch_out_dir = os.path.join(args.out_dir, + f'{name}_patch') + for i, slice_result in enumerate(slice_results): + patch_out_file = os.path.join( + debug_patch_out_dir, + f'{filename}_slice_{i}_result.jpg') + image = mmcv.imconvert(sliced_image_object.images[i], + 'bgr', 'rgb') + + visualizer.add_datasample( + 'patch_result', + image, + data_sample=slice_result, + draw_gt=False, + show=False, + wait_time=0, + out_file=patch_out_file, + pred_score_thr=args.score_thr, + ) + + image_result = merge_results_by_nms( + slice_results, + sliced_image_object.starting_pixels, + src_image_shape=(height, width), + nms_cfg={ + 'type': args.merge_nms_type, + 'iou_threshold': args.merge_iou_thr + }) + + visualizer.add_datasample( + filename, + img, + data_sample=image_result, + draw_gt=False, + show=args.show, + wait_time=0, + out_file=out_file, + pred_score_thr=args.score_thr, + ) + progress_bar.update() + + if not args.show or (args.debug and args.save_patch): + print_log( + f'\nResults have been saved at {os.path.abspath(args.out_dir)}') + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/video_demo.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/video_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..d8317a2c6c777eaa9cc6aab27e55bf53efe9e8fd --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/demo/video_demo.py @@ -0,0 +1,96 @@ +# Copyright (c) OpenMMLab. All rights reserved. +"""Perform MMYOLO inference on a video as: + +```shell +wget -P checkpoint https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth # noqa: E501, E261. + +python demo/video_demo.py \ + demo/video_demo.mp4 \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + checkpoint/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --out demo_result.mp4 +``` +""" +import argparse + +import cv2 +import mmcv +from mmcv.transforms import Compose +from mmdet.apis import inference_detector, init_detector +from mmengine.utils import track_iter_progress + +from mmyolo.registry import VISUALIZERS + + +def parse_args(): + parser = argparse.ArgumentParser(description='MMYOLO video demo') + parser.add_argument('video', help='Video file') + parser.add_argument('config', help='Config file') + parser.add_argument('checkpoint', help='Checkpoint file') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='Bbox score threshold') + parser.add_argument('--out', type=str, help='Output video file') + parser.add_argument('--show', action='store_true', help='Show video') + parser.add_argument( + '--wait-time', + type=float, + default=1, + help='The interval of show (s), 0 is block') + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + assert args.out or args.show, \ + ('Please specify at least one operation (save/show the ' + 'video) with the argument "--out" or "--show"') + + # build the model from a config file and a checkpoint file + model = init_detector(args.config, args.checkpoint, device=args.device) + + # build test pipeline + model.cfg.test_dataloader.dataset.pipeline[ + 0].type = 'mmdet.LoadImageFromNDArray' + test_pipeline = Compose(model.cfg.test_dataloader.dataset.pipeline) + + # init visualizer + visualizer = VISUALIZERS.build(model.cfg.visualizer) + # the dataset_meta is loaded from the checkpoint and + # then pass to the model in init_detector + visualizer.dataset_meta = model.dataset_meta + + video_reader = mmcv.VideoReader(args.video) + video_writer = None + if args.out: + fourcc = cv2.VideoWriter_fourcc(*'mp4v') + video_writer = cv2.VideoWriter( + args.out, fourcc, video_reader.fps, + (video_reader.width, video_reader.height)) + + for frame in track_iter_progress(video_reader): + result = inference_detector(model, frame, test_pipeline=test_pipeline) + visualizer.add_datasample( + name='video', + image=frame, + data_sample=result, + draw_gt=False, + show=False, + pred_score_thr=args.score_thr) + frame = visualizer.get_image() + + if args.show: + cv2.namedWindow('video', 0) + mmcv.imshow(frame, 'video', args.wait_time) + if args.out: + video_writer.write(frame) + + if video_writer: + video_writer.release() + cv2.destroyAllWindows() + + +if __name__ == '__main__': + main() diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docker/Dockerfile b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docker/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..fc65431a2940604118aaf747290442da78741365 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docker/Dockerfile @@ -0,0 +1,36 @@ +ARG PYTORCH="1.9.0" +ARG CUDA="11.1" +ARG CUDNN="8" + +FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel + +ENV TORCH_CUDA_ARCH_LIST="6.0 6.1 7.0 7.5 8.0 8.6+PTX" \ + TORCH_NVCC_FLAGS="-Xfatbin -compress-all" \ + CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ + FORCE_CUDA="1" + +RUN rm /etc/apt/sources.list.d/cuda.list \ + && rm /etc/apt/sources.list.d/nvidia-ml.list \ + && apt-key del 7fa2af80 \ + && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub \ + && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub + +# (Optional) +# RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list && \ +# pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple + +RUN apt-get update \ + && apt-get install -y ffmpeg libsm6 libxext6 git ninja-build libglib2.0-0 libxrender-dev \ + && apt-get clean \ + && rm -rf /var/lib/apt/lists/* + +# Install MMEngine , MMCV and MMDet +RUN pip install --no-cache-dir openmim && \ + mim install --no-cache-dir "mmengine>=0.6.0" "mmcv>=2.0.0rc4,<2.1.0" "mmdet>=3.0.0,<4.0.0" + +# Install MMYOLO +RUN git clone https://github.com/open-mmlab/mmyolo.git /mmyolo && \ + cd /mmyolo && \ + mim install --no-cache-dir -e . + +WORKDIR /mmyolo diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docker/Dockerfile_deployment b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docker/Dockerfile_deployment new file mode 100644 index 0000000000000000000000000000000000000000..8ea1e380b0fab494047f9e2f94545f4e4b0b72e9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docker/Dockerfile_deployment @@ -0,0 +1,65 @@ +FROM nvcr.io/nvidia/pytorch:22.04-py3 + +WORKDIR /openmmlab +ARG ONNXRUNTIME_VERSION=1.8.1 +ENV DEBIAN_FRONTEND=noninteractive \ + APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=DontWarn \ + FORCE_CUDA="1" + +RUN apt-key del 7fa2af80 \ + && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub \ + && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub + +# (Optional) +# RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list \ +# && pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple + +RUN apt-get update \ + && apt-get install -y ffmpeg git libgl1-mesa-glx libopencv-dev \ + libsm6 libspdlog-dev libssl-dev ninja-build libxext6 libxrender-dev \ + libglib2.0-0 vim wget --no-install-recommends \ + && apt-get clean \ + && rm -rf /var/lib/apt/lists/* + +# get onnxruntime +RUN wget -q https://github.com/microsoft/onnxruntime/releases/download/v${ONNXRUNTIME_VERSION}/onnxruntime-linux-x64-${ONNXRUNTIME_VERSION}.tgz \ + && tar -zxvf onnxruntime-linux-x64-${ONNXRUNTIME_VERSION}.tgz \ + && pip install --no-cache-dir onnxruntime-gpu==${ONNXRUNTIME_VERSION} \ + && pip install pycuda + + +# Install OPENMIM MMENGINE MMDET +RUN pip install --no-cache-dir openmim \ + && mim install --no-cache-dir "mmengine>=0.6.0" "mmdet>=3.0.0,<4.0.0" \ + && mim install --no-cache-dir opencv-python==4.5.5.64 opencv-python-headless==4.5.5.64 + +RUN git clone https://github.com/open-mmlab/mmcv.git -b 2.x mmcv \ + && cd mmcv \ + && mim install --no-cache-dir -r requirements/optional.txt \ + && MMCV_WITH_OPS=1 mim install --no-cache-dir -e . -v \ + && cd .. + +# Install MMYOLO +RUN git clone https://github.com/open-mmlab/mmyolo.git -b dev mmyolo \ + && cd mmyolo \ + && mim install --no-cache-dir -e . \ + && cd .. + +# Install MMDEPLOY +ENV ONNXRUNTIME_DIR=/openmmlab/onnxruntime-linux-x64-${ONNXRUNTIME_VERSION} \ + TENSORRT_DIR=/usr/lib/x86_64-linux-gnu \ + CUDNN_DIR=/usr/lib/x86_64-linux-gnu + +RUN git clone https://github.com/open-mmlab/mmdeploy -b dev-1.x mmdeploy \ + && cd mmdeploy \ + && git submodule update --init --recursive \ + && mkdir -p build \ + && cd build \ + && cmake -DMMDEPLOY_TARGET_BACKENDS="ort;trt" -DONNXRUNTIME_DIR=${ONNXRUNTIME_DIR} -DTENSORRT_DIR=${TENSORRT_DIR} -DCUDNN_DIR=${CUDNN_DIR} .. \ + && make -j$(nproc) \ + && make install \ + && cd .. \ + && mim install --no-cache-dir -e . + +# Fix undefined symbol bug + RUN echo -e "\nexport LD_LIBRARY_PATH=${ONNXRUNTIME_DIR}/lib:${TENSORRT_DIR}/lib:${CUDNN_DIR}/lib64:${LD_LIBRARY_PATH}\nldconfig" >> /root/.bashrc diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/README.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f0b79699be51033fec6b1defb413f4abd48220d1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/README.md @@ -0,0 +1,28 @@ +## Build Documentation + +1. Clone MMYOLO + + ```bash + git clone https://github.com/open-mmlab/mmyolo.git + cd mmyolo + ``` + +2. Install the building dependencies of documentation + + ```bash + pip install -r requirements/docs.txt + ``` + +3. Change directory to `docs/en` or `docs/zh_cn` + + ```bash + cd docs/en # or docs/zh_cn + ``` + +4. Build documentation + + ```bash + make html + ``` + +5. Open `_build/html/index.html` with browser diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/Makefile b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..d4bb2cbb9eddb1bb1b4f366623044af8e4830919 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/_static/css/readthedocs.css b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/_static/css/readthedocs.css new file mode 100644 index 0000000000000000000000000000000000000000..353aa9e285a5639b0f34ecb3b16115cff1ad25ed --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/_static/css/readthedocs.css @@ -0,0 +1,6 @@ +.header-logo { + background-image: url("../image/mmyolo-logo.png"); + background-size: 115px 40px; + height: 40px; + width: 115px; +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/_static/image/mmyolo-logo.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/_static/image/mmyolo-logo.png new file mode 100644 index 0000000000000000000000000000000000000000..7be9707ff3a1675a0344cc31e1a41805dc810bfb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/_static/image/mmyolo-logo.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0f8e8c432c88108f3f8905667027f4f4a676727348ed6ca0f49c46baebf0d66 +size 30145 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/advanced_guides/cross-library_application.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/advanced_guides/cross-library_application.md new file mode 100644 index 0000000000000000000000000000000000000000..271d1290a5e772bb20fd26a72035aafc5e7d7e21 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/advanced_guides/cross-library_application.md @@ -0,0 +1 @@ +# MMYOLO cross-library application diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/api.rst b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/api.rst new file mode 100644 index 0000000000000000000000000000000000000000..a45f66ad7ea5e8eb89888ad131468c606393fe41 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/api.rst @@ -0,0 +1,80 @@ +mmyolo.datasets +------------------ + +datasets +^^^^^^^^^^ +.. automodule:: mmyolo.datasets + :members: + +transforms +^^^^^^^^^^^^ +.. automodule:: mmyolo.datasets.transforms + :members: + +mmyolo.engine +-------------- + +hooks +^^^^^^^^^^ +.. automodule:: mmyolo.engine.hooks + :members: + +optimizers +^^^^^^^^^^ +.. automodule:: mmyolo.engine.optimizers + :members: + +mmyolo.models +-------------- + +backbones +^^^^^^^^^^ +.. automodule:: mmyolo.models.backbones + :members: + +data_preprocessor +^^^^^^^^^^^^^^^^^^^^ +.. automodule:: mmyolo.models.data_preprocessor + :members: + +dense_heads +^^^^^^^^^^^^ +.. automodule:: mmyolo.models.dense_heads + :members: + +detectors +^^^^^^^^^^ +.. automodule:: mmyolo.models.detectors + :members: + +layers +^^^^^^^^^^ +.. automodule:: mmyolo.models.layers + :members: + +losses +^^^^^^^^^^ +.. automodule:: mmyolo.models.losses + :members: + +necks +^^^^^^^^^^^^ +.. automodule:: mmyolo.models.necks + :members: + + +task_modules +^^^^^^^^^^^^^^^ +.. automodule:: mmyolo.models.task_modules + :members: + +utils +^^^^^^^^^^ +.. automodule:: mmyolo.models.utils + :members: + + +mmyolo.utils +-------------- +.. automodule::mmyolo.utils + :members: diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/amp_training.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/amp_training.md new file mode 100644 index 0000000000000000000000000000000000000000..ac1fddd817f8f11f44c44918ecea9283c74edb20 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/amp_training.md @@ -0,0 +1,13 @@ +# Automatic mixed precision（AMP）training + +To enable Automatic Mixing Precision (AMP) training, add `--amp` to the end of the training command, which is as follows: + +```shell +python tools/train.py python ./tools/train.py ${CONFIG} --amp +``` + +Specific examples are as follows: + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py --amp +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/freeze_layers.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/freeze_layers.md new file mode 100644 index 0000000000000000000000000000000000000000..4614f324572319e360d9ed90f09b31fdd36ab6b0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/freeze_layers.md @@ -0,0 +1,28 @@ +# Freeze layers + +## Freeze the weight of backbone + +In MMYOLO, we can freeze some `stages` of the backbone network by setting `frozen_stages` parameters, so that these `stage` parameters do not participate in model updating. +It should be noted that `frozen_stages = i` means that all parameters from the initial `stage` to the `i`th `stage` will be frozen. The following is an example of `YOLOv5`. Other algorithms are the same logic. + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + backbone=dict( + frozen_stages=1 # Indicates that the parameters in the first stage and all stages before it are frozen + )) +``` + +## Freeze the weight of neck + +In addition, it's able to freeze the whole `neck` with the parameter `freeze_all` in MMYOLO. The following is an example of `YOLOv5`. Other algorithms are the same logic. + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + neck=dict( + freeze_all=True # If freeze_all=True, all parameters of the neck will be frozen + )) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/mim_usage.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/mim_usage.md new file mode 100644 index 0000000000000000000000000000000000000000..2752ea5f9a8a4e28bccd4b3b9617cbeff265b9df --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/mim_usage.md @@ -0,0 +1,89 @@ +# Use mim to run scripts from other OpenMMLab repositories + +```{note} +1. All script calls across libraries are currently not supported and are being fixed. More examples will be added to this document when the fix is complete. 2. +2. mAP plotting and average training speed calculation are fixed in the MMDetection dev-3.x branch, which currently needs to be installed via the source code to be run successfully. +``` + +## Log Analysis + +### Curve plotting + +`tools/analysis_tools/analyze_logs.py` plots loss/mAP curves given a training log file. Run `pip install seaborn` first to install the dependency. + +```shell +mim run mmdet analyze_logs plot_curve \ + ${LOG} \ # path of train log in json format + [--keys ${KEYS}] \ # the metric that you want to plot, default to 'bbox_mAP' + [--start-epoch ${START_EPOCH}] # the epoch that you want to start, default to 1 + [--eval-interval ${EVALUATION_INTERVAL}] \ # the evaluation interval when training, default to 1 + [--title ${TITLE}] \ # title of figure + [--legend ${LEGEND}] \ # legend of each plot, default to None + [--backend ${BACKEND}] \ # backend of plt, default to None + [--style ${STYLE}] \ # style of plt, default to 'dark' + [--out ${OUT_FILE}] # the path of output file +# [] stands for optional parameters, when actually entering the command line, you do not need to enter [] +``` + +Examples: + +- Plot the classification loss of some run. + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + --keys loss_cls \ + --legend loss_cls + ``` + + + +- Plot the classification and regression loss of some run, and save the figure to a pdf. + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + --keys loss_cls loss_bbox \ + --legend loss_cls loss_bbox \ + --out losses_yolov5_s.pdf + ``` + + + +- Compare the bbox mAP of two runs in the same figure. + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739.log.json \ + --keys bbox_mAP \ + --legend yolov5_s yolov5_n \ + --eval-interval 10 # Note that the evaluation interval must be the same as during training. Otherwise, it will raise an error. + ``` + + + +### Compute the average training speed + +```shell +mim run mmdet analyze_logs cal_train_time \ + ${LOG} \ # path of train log in json format + [--include-outliers] # include the first value of every epoch when computing the average time +``` + +Examples: + +```shell +mim run mmdet analyze_logs cal_train_time \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json +``` + +The output is expected to be like the following. + +```text +-----Analyze train time of yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json----- +slowest epoch 278, average time is 0.1705 s/iter +fastest epoch 300, average time is 0.1510 s/iter +time std over epochs is 0.0026 +average iter time: 0.1556 s/iter +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/module_combination.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/module_combination.md new file mode 100644 index 0000000000000000000000000000000000000000..3f9ffa4c38559fbcc806f3132dc2a91ae0f0dad7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/module_combination.md @@ -0,0 +1 @@ +# Module combination diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/ms_training_testing.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/ms_training_testing.md new file mode 100644 index 0000000000000000000000000000000000000000..b7d88f63217343b7c9c3c3a512f9e2a9e822fe28 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/ms_training_testing.md @@ -0,0 +1,39 @@ +# Multi-scale training and testing + +## Multi-scale training + +The popular YOLOv5, YOLOv6, YOLOv7, YOLOv8 and RTMDet algorithms are supported in MMYOLO currently, and their default configuration is single-scale 640x640 training. There are two implementations of multi-scale training commonly used in the MM family of open source libraries + +1. Each image output in `train_pipeline` is at variable scale, and pad different scales of input images to the same scale by [stack_batch](https://github.com/open-mmlab/mmengine/blob/dbae83c52fa54d6dda08b6692b124217fe3b2135/mmengine/model/base_model/data_preprocessor.py#L260-L261) function in [DataPreprocessor](https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/data_preprocessors/data_preprocessor.py). Most of the algorithms in MMDet are implemented using this approach. +2. Each image output in `train_pipeline` is at a fixed scale, and `DataPreprocessor` performs up- and down-sampling of image batches for multi-scale training directly. + +Both two multi-scale training approaches are supported in MMYOLO. Theoretically, the first implementation can generate richer scales, but its training efficiency is not as good as the second one due to its independent augmentation of a single image. Therefore, we recommend using the second approach. + +Take `configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py` configuration as an example, its default configuration is 640x640 fixed scale training, suppose you want to implement training in multiples of 32 and multi-scale range (480, 800), you can refer to YOLOX practice by [YOLOXBatchSyncRandomResize](https://github.com/open-mmlab/mmyolo/blob/dc85144fab20a970341550794857a2f2f9b11564/mmyolo/models/data_preprocessors/data_preprocessor.py#L20) in the DataPreprocessor. + +Create a new configuration under the `configs/yolov5` path named `configs/yolov5/yolov5_s-v61_fast_1xb12-ms-40e_cat.py` with the following contents. + +```python +_base_ = 'yolov5_s-v61_fast_1xb12-40e_cat.py' + +model = dict( + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + # multi-scale range (480, 800) + random_size_range=(480, 800), + # The output scale needs to be divisible by 32 + size_divisor=32, + interval=1) + ]) +) +``` + +The above configuration will enable multi-scale training. We have already provided this configuration under `configs/yolov5/` for convenience. The rest of the YOLO family of algorithms are similar. + +## Multi-scale testing + +MMYOLO multi-scale testing is equivalent to Test-Time Enhancement TTA and is currently supported, see [Test-Time Augmentation TTA](./tta.md). diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/multi_necks.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/multi_necks.md new file mode 100644 index 0000000000000000000000000000000000000000..b6f2bc252b2f151d80e0c500d3513651b09a704f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/multi_necks.md @@ -0,0 +1,37 @@ +# Apply multiple Necks + +If you want to stack multiple Necks, you can directly set the Neck parameters in the config. MMYOLO supports concatenating multiple Necks in the form of `List`. You need to ensure that the output channel of the previous Neck matches the input channel of the next Neck. If you need to adjust the number of channels, you can insert the `mmdet.ChannelMapper` module to align the number of channels between multiple Necks. The specific configuration is as follows: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +deepen_factor = _base_.deepen_factor +widen_factor = _base_.widen_factor +model = dict( + type='YOLODetector', + neck=[ + dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=[256, 512, 1024], # The out_channels is controlled by widen_factor，so the YOLOv5PAFPN's out_channels equls to out_channels * widen_factor + num_csp_blocks=3, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='SiLU', inplace=True)), + dict( + type='mmdet.ChannelMapper', + in_channels=[128, 256, 512], + out_channels=128, + ), + dict( + type='mmdet.DyHead', + in_channels=128, + out_channels=256, + num_blocks=2, + # disable zero_init_offset to follow official implementation + zero_init_offset=False) + ] + bbox_head=dict(head_module=dict(in_channels=[512,512,512])) # The out_channels is controlled by widen_factor，so the YOLOv5HeadModuled in_channels * widen_factor equals to the last neck's out_channels +) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/output_predictions.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/output_predictions.md new file mode 100644 index 0000000000000000000000000000000000000000..571929900a1d516262cc17e0918c63a61f83c305 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/output_predictions.md @@ -0,0 +1,40 @@ +# Output prediction results + +If you want to save the prediction results as a specific file for offline evaluation, MMYOLO currently supports both json and pkl formats. + +```{note} +The json file only save `image_id`, `bbox`, `score` and `category_id`. The json file can be read using the json library. +The pkl file holds more content than the json file, and also holds information such as the file name and size of the predicted image; the pkl file can be read using the pickle library. The pkl file can be read using the pickle library. +``` + +## Output into json file + +If you want to output the prediction results as a json file, the command is as follows. + +```shell +python tools/test.py {path_to_config} {path_to_checkpoint} --json-prefix {json_prefix} +``` + +The argument after `--json-prefix` should be a filename prefix (no need to enter the `.json` suffix) and can also contain a path. For a concrete example: + +```shell +python tools/test.py configs\yolov5\yolov5_s-v61_syncbn_8xb16-300e_coco.py yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth --json-prefix work_dirs/demo/json_demo +``` + +Running the above command will output the `json_demo.bbox.json` file in the `work_dirs/demo` folder. + +## Output into pkl file + +If you want to output the prediction results as a pkl file, the command is as follows. + +```shell +python tools/test.py {path_to_config} {path_to_checkpoint} --out {path_to_output_file} +``` + +The argument after `--out` should be a full filename (**must be** with a `.pkl` or `.pickle` suffix) and can also contain a path. For a concrete example: + +```shell +python tools/test.py configs\yolov5\yolov5_s-v61_syncbn_8xb16-300e_coco.py yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth --out work_dirs/demo/pkl_demo.pkl +``` + +Running the above command will output the `pkl_demo.pkl` file in the `work_dirs/demo` folder. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/plugins.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/plugins.md new file mode 100644 index 0000000000000000000000000000000000000000..5a0b32364308acf9f08eb369cccae183ad6cc121 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/plugins.md @@ -0,0 +1,34 @@ +# Plugins + +MMYOLO supports adding plugins such as `none_local` and `dropblock` after different stages of Backbone. Users can directly manage plugins by modifying the plugins parameter of the backbone in the config. For example, add `GeneralizedAttention` plugins for `YOLOv5`. The configuration files are as follows: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + backbone=dict( + plugins=[ + dict( + cfg=dict( + type='GeneralizedAttention', + spatial_range=-1, + num_heads=8, + attention_type='0011', + kv_stride=2), + stages=(False, False, True, True)) + ])) +``` + +`cfg` parameter indicates the specific configuration of the plugin. The `stages` parameter indicates whether to add plug-ins after the corresponding stage of the backbone. The length of the list `stages` must be the same as the number of backbone stages. + +MMYOLO currently supports the following plugins: + +
+Supported Plugins + +1. [CBAM](https://github.com/open-mmlab/mmyolo/blob/dev/mmyolo/models/plugins/cbam.py#L86) +2. [GeneralizedAttention](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/bricks/generalized_attention.py#L13) +3. [NonLocal2d](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/bricks/non_local.py#L250) +4. [ContextBlock](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/bricks/context_block.py#L18) + +
diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/resume_training.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/resume_training.md new file mode 100644 index 0000000000000000000000000000000000000000..1e1184a728f2d22a71f52a2c2f9a1e3671bc3c41 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/resume_training.md @@ -0,0 +1,9 @@ +# Resume training + +Resume training means to continue training from the state saved from one of the previous trainings, where the state includes the model weights, the state of the optimizer and the optimizer parameter adjustment strategy. + +The user can add `--resume` at the end of the training command to resume training, and the program will automatically load the latest weight file from `work_dirs` to resume training. If there is an updated checkpoint in `work_dir` (e.g. the training was interrupted during the last training), the training will be resumed from that checkpoint, otherwise (e.g. the last training did not have time to save the checkpoint or a new training task was started) the training will be restarted. Here is an example of resuming training: + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py --resume +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/set_random_seed.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/set_random_seed.md new file mode 100644 index 0000000000000000000000000000000000000000..c45c165f4323e5e522daccf0b1fbbb9bbf1f4b2a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/set_random_seed.md @@ -0,0 +1,18 @@ +# Set the random seed + +If you want to set the random seed during training, you can use the following command. + +```shell +python ./tools/train.py \ + ${CONFIG} \ # path of the config file + --cfg-options randomness.seed=2023 \ # set seed to 2023 + [randomness.diff_rank_seed=True] \ # set different seeds according to global rank + [randomness.deterministic=True] # set the deterministic option for CUDNN backend +# [] stands for optional parameters, when actually entering the command line, you do not need to enter [] +``` + +`randomness` has three parameters that can be set, with the following meanings. + +- `randomness.seed=2023`, set the random seed to 2023. +- `randomness.diff_rank_seed=True`, set different seeds according to global rank. Defaults to False. +- `randomness.deterministic=True`, set the deterministic option for cuDNN backend, i.e., set `torch.backends.cudnn.deterministic` to True and `torch.backends.cudnn.benchmark` to False. Defaults to False. See https://pytorch.org/docs/stable/notes/randomness.html for more details. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/set_syncbn.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/set_syncbn.md new file mode 100644 index 0000000000000000000000000000000000000000..dba33be6e39b268c7a286b2c3d54469b5665d42c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/set_syncbn.md @@ -0,0 +1 @@ +# Enabling and disabling SyncBatchNorm diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/single_multi_channel_applications.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/single_multi_channel_applications.md new file mode 100644 index 0000000000000000000000000000000000000000..30932708bb59ae226e1282ca70dbdca023f32a0f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/single_multi_channel_applications.md @@ -0,0 +1,188 @@ +# Single and multi-channel application examples + +## Training example on a single-channel image dataset + +The default training images in MMYOLO are all color three-channel data. If you want to use a single-channel dataset for training and testing, it is expected that the following modifications are needed. + +1. All image processing pipelines have to support single channel operations +2. The input channel of the first convolutional layer of the backbone network of the model needs to be changed from 3 to 1 +3. If you wish to load COCO pre-training weights, you need to handle the first convolutional layer weight size mismatch + +The following uses the `cat` dataset as an example to describe the entire modification process, if you are using a custom grayscale image dataset, you can skip the dataset preprocessing step. + +### 1 Dataset pre-processing + +The processing training of the custom dataset can be found in [Annotation-to-deployment workflow for custom dataset](../recommended_topics/labeling_to_deployment_tutorials.md)。 + +`cat` is a three-channel color image dataset. For demonstration purpose, you can run the following code and commands to replace the dataset images with single-channel images for subsequent validation. + +**1. Download the `cat` dataset for decompression** + +```shell +python tools/misc/download_dataset.py --dataset-name cat --save-dir ./data/cat --unzip --delete +``` + +**2. Convert datasets to grayscale maps** + +```python +import argparse +import imghdr +import os +from typing import List +import cv2 + +def parse_args(): + parser = argparse.ArgumentParser(description='data_path') + parser.add_argument('path', type=str, help='Original dataset path') + return parser.parse_args() + +def main(): + args = parse_args() + + path = args.path + '/images/' + save_path = path + file_list: List[str] = os.listdir(path) + # Grayscale conversion of each imager + for file in file_list: + if imghdr.what(path + '/' + file) != 'jpeg': + continue + img = cv2.imread(path + '/' + file) + img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + cv2.imwrite(save_path + '/' + file, img) + +if __name__ == '__main__': + main() +``` + +Name the above script as `cvt_single_channel.py`, and run the command as: + +```shell +python cvt_single_channel.py data/cat +``` + +### 2 Modify the base configuration file + +**At present, some image processing functions of MMYOLO, such as color space transformation, are not compatible with single-channel images, so if we use single-channel data for training directly, we need to modify part of the pipeline, which is a large amount of work**. In order to solve the incompatibility problem, the recommended approach is to load the single-channel image as a three-channel image as a three-channel data, but convert it to single-channel format before input to the network. This approach will slightly increase the arithmetic burden, but the user basically does not need to modify the code to use. + +Take `projects/misc/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py` as the `base` configuration, copy it to the `configs/yolov5` directory, and add `yolov5_s- v61_syncbn_fast_1xb32-100e_cat_single_channel.py` file. We can inherit `YOLOv5DetDataPreprocessor` from the `mmyolo/models/data_preprocessors/data_preprocessor.py` file and name the new class `YOLOv5SCDetDataPreprocessor`, in which convert the image to a single channel, add the dependency library and register the new class in `mmyolo/models/data_preprocessors/__init__.py`. The `YOLOv5SCDetDataPreprocessor` sample code is： + +```python +@MODELS.register_module() +class YOLOv5SCDetDataPreprocessor(YOLOv5DetDataPreprocessor): + """Rewrite collate_fn to get faster training speed. + + Note: It must be used together with `mmyolo.datasets.utils.yolov5_collate` + """ + + def forward(self, data: dict, training: bool = False) -> dict: + """Perform normalization, padding, bgr2rgb conversion and convert to single channel image based on ``DetDataPreprocessor``. + + Args: + data (dict): Data sampled from dataloader. + training (bool): Whether to enable training time augmentation. + + Returns: + dict: Data in the same format as the model input. + """ + if not training: + return super().forward(data, training) + + data = self.cast_data(data) + inputs, data_samples = data['inputs'], data['data_samples'] + assert isinstance(data['data_samples'], dict) + + # TODO: Supports multi-scale training + if self._channel_conversion and inputs.shape[1] == 3: + inputs = inputs[:, [2, 1, 0], ...] + + if self._enable_normalize: + inputs = (inputs - self.mean) / self.std + + if self.batch_augments is not None: + for batch_aug in self.batch_augments: + inputs, data_samples = batch_aug(inputs, data_samples) + + img_metas = [{'batch_input_shape': inputs.shape[2:]}] * len(inputs) + data_samples = { + 'bboxes_labels': data_samples['bboxes_labels'], + 'img_metas': img_metas + } + + # Convert to single channel image + inputs = inputs.mean(dim=1, keepdim=True) + + return {'inputs': inputs, 'data_samples': data_samples} +``` + +At this point, the `yolov5_s-v61_syncbn_fast_1xb32-100e_cat_single_channel.py` configuration file reads as follows. + +```python +_base_ = 'yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py' + +_base_.model.data_preprocessor.type = 'YOLOv5SCDetDataPreprocessor' +``` + +### 3 Pre-training model loading problem + +When using a pre-trained 3-channel model directly, it's theoretically possible to experience a decrease in accuracy, though this has not been experimentally verified. To mitigate this potential issue, there are several solutions, including adjusting the weight of each channel in the input layer. One approach is to set the weight of each channel in the input layer to the average of the weights of the original 3 channels. Alternatively, the weight of each channel could be set to one of the weights of the original 3 channels, or the input layer could be trained directly without modifying the weights, depending on the specific circumstances. In this work, we chose to adjust the weights of the 3 channels in the input layer to the average of the weights of the pre-trained 3 channels. + +```python +import torch + +def main(): + # Load weights file + state_dict = torch.load( + 'checkpoints/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' + ) + + # Modify input layer weights + weights = state_dict['state_dict']['backbone.stem.conv.weight'] + avg_weight = weights.mean(dim=1, keepdim=True) + state_dict['state_dict']['backbone.stem.conv.weight'] = avg_weight + + # Save the modified weights to a new file + torch.save( + state_dict, + 'checkpoints/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187_single_channel.pth' + ) + +if __name__ == '__main__': + main() +``` + +At this point, the `yolov5_s-v61_syncbn_fast_1xb32-100e_cat_single_channel.py` configuration file reads as follows： + +```python +_base_ = 'yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py' + +_base_.model.data_preprocessor.type = 'YOLOv5SCDetDataPreprocessor' + +load_from = './checkpoints/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187_single_channel.pth' +``` + +### 4 Model training effect + + + +The left figure shows the actual label and the right figure shows the target detection result. + +```shell + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.958 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.958 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.881 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.969 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.969 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.969 +bbox_mAP_copypaste: 0.958 1.000 1.000 -1.000 -1.000 0.958 +Epoch(val) [100][116/116] coco/bbox_mAP: 0.9580 coco/bbox_mAP_50: 1.0000 coco/bbox_mAP_75: 1.0000 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.9580 +``` + +## Training example on a multi-channel image dataset + +TODO diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/specify_device.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/specify_device.md new file mode 100644 index 0000000000000000000000000000000000000000..72c8017e552040413e118a85ad7785fb854a8d59 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/specify_device.md @@ -0,0 +1,23 @@ +# Specify specific GPUs during training or inference + +If you have multiple GPUs, such as 8 GPUs, numbered `0, 1, 2, 3, 4, 5, 6, 7`, GPU 0 will be used by default for training or inference. If you want to specify other GPUs for training or inference, you can use the following commands: + +```shell +CUDA_VISIBLE_DEVICES=5 python ./tools/train.py ${CONFIG} #train +CUDA_VISIBLE_DEVICES=5 python ./tools/test.py ${CONFIG} ${CHECKPOINT_FILE} #test +``` + +If you set `CUDA_VISIBLE_DEVICES` to -1 or a number greater than the maximum GPU number, such as 8, the CPU will be used for training or inference. + +If you want to use several of these GPUs to train in parallel, you can use the following command: + +```shell +CUDA_VISIBLE_DEVICES=0,1,2,3 ./tools/dist_train.sh ${CONFIG} ${GPU_NUM} +``` + +Here the `GPU_NUM` is 4. In addition, if multiple tasks are trained in parallel on one machine and each task requires multiple GPUs, the PORT of each task need to be set differently to avoid communication conflict, like the following commands: + +```shell +CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG} 4 +CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG} 4 +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/tta.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/tta.md new file mode 100644 index 0000000000000000000000000000000000000000..517d34b8b67f4336c1e2acd93304c0e47af36571 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/common_usage/tta.md @@ -0,0 +1,87 @@ +# TTA Related Notes + +## Test Time Augmentation (TTA) + +MMYOLO support for TTA in v0.5.0+, so that users can specify the `-tta` parameter to enable it during evaluation. Take `YOLOv5-s` as an example, its single GPU TTA test command is as follows + +```shell +python tools/test.py configs/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739-b804c1ad.pth --tta +``` + +For TTA to work properly, you must ensure that the variables `tta_model` and `tta_pipeline` are present in the configuration, see [det_p5_tta.py](https://github.com/open-mmlab/mmyolo/blob/dev/configs/_base_/det_p5_tta.py) for details. + +The default TTA in MMYOLO performs 3 multi-scale enhancements, followed by 2 horizontal flip enhancements, for a total of 6 parallel pipelines. take `YOLOv5-s` as an example, its TTA configuration is as follows + +```python +img_scales = [(640, 640), (320, 320), (960, 960)] + +_multiscale_resize_transforms = [ + dict( + type='Compose', + transforms=[ + dict(type='YOLOv5KeepRatioResize', scale=s), + dict( + type='LetterResize', + scale=s, + allow_scale_up=False, + pad_val=dict(img=114)) + ]) for s in img_scales +] + +tta_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='TestTimeAug', + transforms=[ + _multiscale_resize_transforms, + [ + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'flip', + 'flip_direction')) + ] + ]) +] +``` + +The schematic diagram is shown below. + +```text + LoadImageFromFile + / | \ +(RatioResize,LetterResize) (RatioResize,LetterResize) (RatioResize,LetterResize) + / \ / \ / \ + RandomFlip RandomFlip RandomFlip RandomFlip RandomFlip RandomFlip + | | | | | | + LoadAnn LoadAnn LoadAnn LoadAnn LoadAnn LoadAnn + | | | | | | + PackDetIn PackDetIn PackDetIn PackDetIn PackDetIn PackDetIn +``` + +You can modify `img_scales` to support different multi-scale enhancements, or you can insert a new pipeline to implement custom TTA requirements. Assuming you only want to do horizontal flip enhancements, the configuration should be modified as follows. + +```python +tta_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='mmdet.RandomFlip', prob=1.), + dict(type='mmdet.RandomFlip', prob=0.) + ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)], + [ + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param', 'flip', + 'flip_direction')) + ] + ]) +] +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/conf.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/conf.py new file mode 100644 index 0000000000000000000000000000000000000000..437a257a34618f2d7022dbbe0b58928c671b800e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/conf.py @@ -0,0 +1,115 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import subprocess +import sys + +import pytorch_sphinx_theme + +sys.path.insert(0, os.path.abspath('../../')) + +# -- Project information ----------------------------------------------------- + +project = 'MMYOLO' +copyright = '2022, OpenMMLab' +author = 'MMYOLO Authors' +version_file = '../../mmyolo/version.py' + + +def get_version(): + with open(version_file) as f: + exec(compile(f.read(), version_file, 'exec')) + return locals()['__version__'] + + +# The full version, including alpha/beta/rc tags +release = get_version() + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.napoleon', + 'sphinx.ext.viewcode', + 'myst_parser', + 'sphinx_markdown_tables', + 'sphinx_copybutton', +] + +myst_enable_extensions = ['colon_fence'] +myst_heading_anchors = 3 + +autodoc_mock_imports = [ + 'matplotlib', 'pycocotools', 'terminaltables', 'mmyolo.version', 'mmcv.ops' +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# +source_suffix = { + '.rst': 'restructuredtext', + '.md': 'markdown', +} + +# The master toctree document. +master_doc = 'index' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +# html_theme = 'sphinx_rtd_theme' +html_theme = 'pytorch_sphinx_theme' +html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()] + +html_theme_options = { + 'menu': [ + { + 'name': 'GitHub', + 'url': 'https://github.com/open-mmlab/mmyolo' + }, + ], + # Specify the language of shared menu + 'menu_lang': 'en', +} + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] +html_css_files = ['css/readthedocs.css'] + +# -- Extension configuration ------------------------------------------------- +# Ignore >>> when copying code +copybutton_prompt_text = r'>>> |\.\.\. ' +copybutton_prompt_is_regexp = True + + +def builder_inited_handler(app): + subprocess.run(['./stat.py']) + + +def setup(app): + app.connect('builder-inited', builder_inited_handler) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_instance_segmentation.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_instance_segmentation.md new file mode 100644 index 0000000000000000000000000000000000000000..b42e25f646f7adbc49f1b323e0016d62dd14a3ab --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_instance_segmentation.md @@ -0,0 +1,332 @@ +# 15 minutes to get started with MMYOLO instance segmentation + +Instance segmentation is a task in computer vision that aims to segment each object in an image and assign each object a unique identifier. + +Unlike semantic segmentation, instance segmentation not only segments out different categories in an image, but also separates different instances of the same category. + +
+Instance Segmentation +
+ +Taking the downloadable balloon dataset as an example, I will guide you through a 15-minute easy introduction to MMYOLO instance segmentation. The entire process includes the following steps: + +- [Installation](#installation) +- [Dataset](#dataset) +- [Config](#config) +- [Training](#training) +- [Testing](#testing) +- [EasyDeploy](#easydeploy-deployment) + +In this tutorial, we will use YOLOv5-s as an example. For the demo configuration of the balloon dataset with other YOLO series algorithms, please refer to the corresponding algorithm configuration folder. + +## Installation + +Assuming you've already installed Conda in advance, then install PyTorch using the following commands. + +```{note} +Note: Since this repo uses OpenMMLab 2.0, it is better to create a new conda virtual environment to prevent conflicts with the repo installed in OpenMMLab 1.0. +``` + +```shell +conda create -n mmyolo python=3.8 -y +conda activate mmyolo +# If you have GPU +conda install pytorch torchvision -c pytorch +# If you only have CPU +# conda install pytorch torchvision cpuonly -c pytorch +``` + +Install MMYOLO and dependency libraries using the following commands. + +```shell +git clone https://github.com/open-mmlab/mmyolo.git +cd mmyolo +pip install -U openmim +mim install -r requirements/mminstall.txt +# Install albumentations +mim install -r requirements/albu.txt +# Install MMYOLO +mim install -v -e . +# "-v" means verbose, or more output +# "-e" means installing a project in editable mode, +# thus any local modifications made to the code will take effect without reinstallation. +``` + +For details about how to configure the environment, see [Installation and verification](./installation.md). + +## Dataset + +The Balloon dataset is a single-class dataset that consists of 74 images and includes annotated information required for training. Here is an example image from the dataset: + +
+balloon dataset +
+ +You can download and use it directly by the following command: + +```shell +python tools/misc/download_dataset.py --dataset-name balloon --save-dir ./data/balloon --unzip --delete +python ./tools/dataset_converters/balloon2coco.py +``` + +The data for the MMYOLO project is located in the MMYOLO project directory. The `train.json` and `val.json` files store the annotations in COCO format, while the `data/balloon/train` and `data/balloon/val` directories contain all the images for the dataset. + +## Config + +Taking YOLOv5 algorithm as an example, considering the limited GPU memory of users, we need to modify some default training parameters to make them run smoothly. The key parameters to be modified are as follows: + +- YOLOv5 is an Anchor-Based algorithm, and different datasets need to calculate suitable anchors adaptively. +- The default config uses 8 GPUs with a batch size of 16 per GPU. Now change it to a single GPU with a batch size of 12. +- In principle, the learning rate should be linearly scaled accordingly when the batch size is changed, but actual measurements have found that this is not necessary. + +To perform the specific operation, create a new configuration file named `yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py` in the `configs/yolov5/ins_seg` folder. For convenience, we have already provided this configuration file. Copy the following contents into the configuration file. + +```python +_base_ = './yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py' # noqa + +data_root = 'data/balloon/' # dataset root +# Training set annotation file of json path +train_ann_file = 'train.json' +train_data_prefix = 'train/' # Dataset prefix +# Validation set annotation file of json path +val_ann_file = 'val.json' +val_data_prefix = 'val/' +metainfo = { + 'classes': ('balloon', ), # dataset category name + 'palette': [ + (220, 20, 60), + ] +} +num_classes = 1 +# Set batch size to 4 +train_batch_size_per_gpu = 4 +# dataloader num workers +train_num_workers = 2 +log_interval = 1 +##################### +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + data_prefix=dict(img=train_data_prefix), + ann_file=train_ann_file)) +val_dataloader = dict( + dataset=dict( + data_root=data_root, + metainfo=metainfo, + data_prefix=dict(img=val_data_prefix), + ann_file=val_ann_file)) +test_dataloader = val_dataloader +val_evaluator = dict(ann_file=data_root + val_ann_file) +test_evaluator = val_evaluator +default_hooks = dict(logger=dict(interval=log_interval)) +##################### + +model = dict(bbox_head=dict(head_module=dict(num_classes=num_classes))) +``` + +The above configuration inherits from `yolov5_ins_s-v61_syncbn_fast_8xb16-300e_coco_instance.py` and updates configurations such as `data_root`, `metainfo`, `train_dataloader`, `val_dataloader`, `num_classes`, etc., based on the characteristics of the balloon dataset. + +## Training + +```shell +python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py +``` + +After running the training command mentioned above, the folder `work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance` will be automatically generated. The weight files and the training configuration file for this session will be saved in this folder. On a lower-end GPU like the GTX 1660, the entire training process will take approximately 30 minutes. + +
+image +
+ +The performance on `val.json` is as follows: + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.330 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.509 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.317 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.103 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.417 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.150 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.396 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.454 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.317 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525 +``` + +The above performance is obtained by printing using the COCO API, where -1 indicates the absence of objects of that scale. + +### Some Notes + +The key warnings are printed during training: + +- You are using `YOLOv5Head` with num_classes == 1. The loss_cls will be 0. This is a normal phenomenon. + +The warning is because the `num_classes` currently trained is 1, the loss of the classification branch is always 0 according to the community of the YOLOv5 algorithm, which is a normal phenomenon. + +### Training is resumed after the interruption + +If you stop training, you can add `--resume` to the end of the training command and the program will automatically resume training with the latest weights file from `work_dirs`. + +```shell +python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py --resume +``` + +### Save GPU memory strategy + +The above config requires about 3G RAM, so if you don't have enough, consider turning on mixed-precision training + +```shell +python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py --amp +``` + +### Training visualization + +MMYOLO currently supports local, TensorBoard, WandB and other back-end visualization. The default is to use local visualization, and you can switch to WandB and other real-time visualization of various indicators in the training process. + +#### 1 WandB + +WandB visualization need registered in website, and in the https://wandb.ai/settings for wandb API Keys. + +
+image +
+ +```shell +pip install wandb +# After running wandb login, enter the API Keys obtained above, and the login is successful. +wandb login +``` + +Add the wandb config at the end of config file we just created: `configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py`. + +```python +visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) +``` + +Running the training command and you will see the loss, learning rate, and coco/bbox_mAP visualizations in the link. + +```shell +python tools/train.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py +``` + +#### 2 Tensorboard + +Install Tensorboard package using the following command: + +```shell +pip install tensorboard +``` + +Add the `tensorboard` config at the end of config file we just created: `configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py`. + +```python +visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')]) +``` + +After re-running the training command, Tensorboard file will be generated in the visualization folder `work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/{timestamp}/vis_data`. +We can use Tensorboard to view the loss, learning rate, and coco/bbox_mAP visualizations from a web link by running the following command: + +```shell +tensorboard --logdir=work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance +``` + +## Testing + +```shell +python tools/test.py configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py \ + work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/best_coco_bbox_mAP_epoch_300.pth \ + --show-dir show_results +``` + +Run the above test command, you can not only get the AP performance printed in the **Training** section, You can also automatically save the result images to the `work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/{timestamp}/show_results` folder. Below is one of the result images, the left image is the actual annotation, and the right image is the inference result of the model. + +
+result_img +
+ +You can also visualize model inference results in a browser window if you use `WandbVisBackend` or `TensorboardVisBackend`. + +## Feature map visualization + +MMYOLO provides visualization scripts for feature map to analyze the current model training. Please refer to [Feature Map Visualization](../recommended_topics/visualization.md) + +Due to the bias of direct visualization of `test_pipeline`, we need to modify the `test_pipeline` of `configs/yolov5/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py` + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +``` + +to the following config: + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # modify the LetterResize to mmdet.Resize + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +``` + +Let's choose the `data/balloon/train/3927754171_9011487133_b.jpg` image as an example to visualize the output feature maps of YOLOv5 backbone and neck layers. + +**1. Visualize the three channels of YOLOv5s backbone** + +```shell +python demo/featmap_vis_demo.py data/balloon/train/3927754171_9011487133_b.jpg \ + configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py \ + work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/best_coco_bbox_mAP_epoch_300.pth \ --target-layers backbone \ + --channel-reduction squeeze_mean +``` + +
+image +
+ +The result will be saved to the output folder in current path. Three output feature maps plotted in the above figure correspond to small, medium and large output feature maps. + +**2. Visualize the three channels of YOLOv5 neck** + +```shell +python demo/featmap_vis_demo.py data/balloon/train/3927754171_9011487133_b.jpg \ + configs/yolov5/ins_seg/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance.py \ + work_dirs/yolov5_ins_s-v61_syncbn_fast_8xb16-300e_balloon_instance/best_coco_bbox_mAP_epoch_300.pth \ --target-layers neck \ + --channel-reduction squeeze_mean +``` + +
+image +
+**3. Grad-Based CAM visualization** + +TODO + +## EasyDeploy deployment + +TODO + +The full content above can be viewed in [15_minutes_object_detection.ipynb](../../../demo/15_minutes_object_detection.ipynb). This is the end of the tutorial. If you encounter problems during training or testing, please check the [common troubleshooting steps](../recommended_topics/troubleshooting_steps.md) first and feel free to open an [issue](https://github.com/open-mmlab/mmyolo/issues/new/choose) if you still can't solve it. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_object_detection.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_object_detection.md new file mode 100644 index 0000000000000000000000000000000000000000..354b2e7080d727d9ccd91b48b904b4fb59772888 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_object_detection.md @@ -0,0 +1,535 @@ +# 15 minutes to get started with MMYOLO object detection + +Object detection task refers to that given a picture, the network predicts all the categories of objects included in the picture and the corresponding boundary boxes + +
+object detection +
+ +Take the small dataset of cat as an example, you can easily learn MMYOLO object detection in 15 minutes. The whole process consists of the following steps: + +- [Installation](#installation) +- [Dataset](#dataset) +- [Config](#config) +- [Training](#training) +- [Testing](#testing) +- [EasyDeploy](#easydeploy-deployment) + +In this tutorial, we take YOLOv5-s as an example. For the rest of the YOLO series algorithms, please see the corresponding algorithm configuration folder. + +## Installation + +Assuming you've already installed Conda in advance, then install PyTorch using the following commands. + +```{note} +Note: Since this repo uses OpenMMLab 2.0, it is better to create a new conda virtual environment to prevent conflicts with the repo installed in OpenMMLab 1.0. +``` + +```shell +conda create -n mmyolo python=3.8 -y +conda activate mmyolo +# If you have GPU +conda install pytorch torchvision -c pytorch +# If you only have CPU +# conda install pytorch torchvision cpuonly -c pytorch +``` + +Install MMYOLO and dependency libraries using the following commands. + +```shell +git clone https://github.com/open-mmlab/mmyolo.git +cd mmyolo +pip install -U openmim +mim install -r requirements/mminstall.txt +# Install albumentations +mim install -r requirements/albu.txt +# Install MMYOLO +mim install -v -e . +# "-v" means verbose, or more output +# "-e" means installing a project in editable mode, +# thus any local modifications made to the code will take effect without reinstallation. +``` + +For details about how to configure the environment, see [Installation and verification](./installation.md). + +## Dataset + +The Cat dataset is a single-category dataset consisting of 144 pictures (the original pictures are provided by @RangeKing, and cleaned by @PeterH0323), which contains the annotation information required for training. The sample image is shown below: + +
+cat dataset +
+ +You can download and use it directly by the following command: + +```shell +python tools/misc/download_dataset.py --dataset-name cat --save-dir ./data/cat --unzip --delete +``` + +This dataset is automatically downloaded to the `./data/cat` dir with the following directory structure: + +
+image +
+ +The cat dataset is located in the mmyolo project dir, and `data/cat/annotations` stores annotations in COCO format, and `data/cat/images` stores all images + +## Config + +Taking YOLOv5 algorithm as an example, considering the limited GPU memory of users, we need to modify some default training parameters to make them run smoothly. The key parameters to be modified are as follows: + +- YOLOv5 is an Anchor-Based algorithm, and different datasets need to calculate suitable anchors adaptively +- The default config uses 8 GPUs with a batch size of 16 per GPU. Now change it to a single GPU with a batch size of 12. +- The default training epoch is 300. Change it to 40 epoch +- Given the small size of the dataset, we opted to use fixed backbone weights +- In principle, the learning rate should be linearly scaled accordingly when the batch size is changed, but actual measurements have found that this is not necessary + +Create a `yolov5_s-v61_fast_1xb12-40e_cat.py` config file in the `configs/yolov5` folder (we have provided this config for you to use directly) and copy the following into the config file. + +```python +# Inherit and overwrite part of the config based on this config +_base_ = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +data_root = './data/cat/' # dataset root +class_name = ('cat', ) # dataset category name +num_classes = len(class_name) # dataset category number +# metainfo is a configuration that must be passed to the dataloader, otherwise it is invalid +# palette is a display color for category at visualization +# The palette length must be greater than or equal to the length of the classes +metainfo = dict(classes=class_name, palette=[(20, 220, 60)]) + +# Adaptive anchor based on tools/analysis_tools/optimize_anchors.py +anchors = [ + [(68, 69), (154, 91), (143, 162)], # P3/8 + [(242, 160), (189, 287), (391, 207)], # P4/16 + [(353, 337), (539, 341), (443, 432)] # P5/32 +] +# Max training 40 epoch +max_epochs = 40 +# Set batch size to 12 +train_batch_size_per_gpu = 12 +# dataloader num workers +train_num_workers = 4 + +# load COCO pre-trained weight +load_from = 'https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' # noqa + +model = dict( + # Fixed the weight of the entire backbone without training + backbone=dict(frozen_stages=4), + bbox_head=dict( + head_module=dict(num_classes=num_classes), + prior_generator=dict(base_sizes=anchors) + )) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + data_root=data_root, + metainfo=metainfo, + # Dataset annotation file of json path + ann_file='annotations/trainval.json', + # Dataset prefix + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +_base_.optim_wrapper.optimizer.batch_size_per_gpu = train_batch_size_per_gpu + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +default_hooks = dict( + # Save weights every 10 epochs and a maximum of two weights can be saved. + # The best model is saved automatically during model evaluation + checkpoint=dict(interval=10, max_keep_ckpts=2, save_best='auto'), + # The warmup_mim_iter parameter is critical. + # The default value is 1000 which is not suitable for cat datasets. + param_scheduler=dict(max_epochs=max_epochs, warmup_mim_iter=10), + # The log printing interval is 5 + logger=dict(type='LoggerHook', interval=5)) +# The evaluation interval is 10 +train_cfg = dict(max_epochs=max_epochs, val_interval=10) +``` + +The above config is inherited from `yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py`. According to the characteristics of cat dataset updated `data_root`, `metainfo`, `train_dataloader`, `val_dataloader`, `num_classes` and other config. + +## Training + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py +``` + +Run the above training command, `work_dirs/yolov5_s-v61_fast_1xb12-40e_cat` folder will be automatically generated, the checkpoint file and the training config file will be saved in this folder. On a low-end 1660 GPU, the entire training process takes about eight minutes. + +
+image +
+ +The performance on `test.json` is as follows: + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.631 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.909 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.747 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.631 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.627 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.703 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.703 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.703 +``` + +The above properties are printed via the COCO API, where -1 indicates that no object exists for the scale. According to the rules defined by COCO, the Cat dataset contains all large sized objects, and there are no small or medium-sized objects. + +### Some Notes + +Two key warnings are printed during training: + +- You are using `YOLOv5Head` with num_classes == 1. The loss_cls will be 0. This is a normal phenomenon. +- The model and loaded state dict do not match exactly + +Neither of these warnings will have any impact on performance. The first warning is because the `num_classes` currently trained is 1, the loss of the classification branch is always 0 according to the community of the YOLOv5 algorithm, which is a normal phenomenon. The second warning is because we are currently training in fine-tuning mode, we load the COCO pre-trained weights for 80 classes, +This will lead to the final Head module convolution channel number does not correspond, resulting in this part of the weight can not be loaded, which is also a normal phenomenon. + +### Training is resumed after the interruption + +If you stop training, you can add `--resume` to the end of the training command and the program will automatically resume training with the latest weights file from `work_dirs`. + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py --resume +``` + +### Save GPU memory strategy + +The above config requires about 3G RAM, so if you don't have enough, consider turning on mixed-precision training + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py --amp +``` + +### Training visualization + +MMYOLO currently supports local, TensorBoard, WandB and other back-end visualization. The default is to use local visualization, and you can switch to WandB and other real-time visualization of various indicators in the training process. + +#### 1 WandB + +WandB visualization need registered in website, and in the https://wandb.ai/settings for wandb API Keys. + +
+image +
+ +```shell +pip install wandb +# After running wandb login, enter the API Keys obtained above, and the login is successful. +wandb login +``` + +Add the wandb config at the end of config file we just created: `configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py`. + +```python +visualizer = dict(vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) +``` + +Running the training command and you will see the loss, learning rate, and coco/bbox_mAP visualizations in the link. + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py +``` + +
+image +
+
+image +
+ +#### 2 Tensorboard + +Install Tensorboard package: + +```shell +pip install tensorboard +``` + +Add the `tensorboard` config at the end of config file we just created: `configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py`. + +```python +visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')]) +``` + +After re-running the training command, Tensorboard file will be generated in the visualization folder `work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/{timestamp}/vis_data`. +We can use Tensorboard to view the loss, learning rate, and coco/bbox_mAP visualizations from a web link by running the following command: + +```shell +tensorboard --logdir=work_dirs/yolov5_s-v61_fast_1xb12-40e_cat +``` + +## Testing + +```shell +python tools/test.py configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --show-dir show_results +``` + +Run the above test command, you can not only get the AP performance printed in the **Training** section, You can also automatically save the result images to the `work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/{timestamp}/show_results` folder. Below is one of the result images, the left image is the actual annotation, and the right image is the inference result of the model. + +
+result_img +
+ +You can also visualize model inference results in a browser window if you use 'WandbVisBackend' or 'TensorboardVisBackend'. + +## Feature map visualization + +MMYOLO provides visualization scripts for feature map to analyze the current model training. Please refer to [Feature Map Visualization](../recommended_topics/visualization.md) + +Due to the bias of direct visualization of `test_pipeline`, we need to modify the `test_pipeline` of `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py` + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +``` + +to the following config: + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # modify the LetterResize to mmdet.Resize + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +``` + +Let's choose the `data/cat/images/IMG_20221020_112705.jpg` image as an example to visualize the output feature maps of YOLOv5 backbone and neck layers. + +**1. Visualize the three channels of YOLOv5 backbone** + +```shell +python demo/featmap_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --target-layers backbone \ + --channel-reduction squeeze_mean +``` + +
+image +
+ +The result will be saved to the output folder in current path. Three output feature maps plotted in the above figure correspond to small, medium and large output feature maps. As the backbone of this training is not actually involved in training, it can be seen from the above figure that the big object cat is predicted on the small feature map, which is in line with the idea of hierarchical detection of object detection. + +**2. Visualize the three channels of YOLOv5 neck** + +```shell +python demo/featmap_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --target-layers neck \ + --channel-reduction squeeze_mean +``` + +
+image +
+ +As can be seen from the above figure, because neck is involved in training, and we also reset anchor, the three output feature maps are forced to simulate the same scale object, resulting in the three output maps of neck are similar, which destroys the original pre-training distribution of backbone. At the same time, it can also be seen that 40 epochs are not enough to train the above dataset, and the feature maps do not perform well. + +**3. Grad-Based CAM visualization** + +Based on the above feature map visualization, we can analyze Grad CAM at the feature layer of bbox level. + +Install `grad-cam` package: + +```shell +pip install "grad-cam" +``` + +(a) View Grad CAM of the minimum output feature map of the neck + +```shell +python demo/boxam_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --target-layer neck.out_layers[2] +``` + +
+image +
+ +(b) View Grad CAM of the medium output feature map of the neck + +```shell +python demo/boxam_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --target-layer neck.out_layers[1] +``` + +
+image +
+ +(c) View Grad CAM of the maximum output feature map of the neck + +```shell +python demo/boxam_vis_demo.py data/cat/images/IMG_20221020_112705.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --target-layer neck.out_layers[0] +``` + +
+image +
+ +## EasyDeploy deployment + +Here we'll use MMYOLO's [EasyDeploy](../../../projects/easydeploy/) to demonstrate the transformation deployment and basic inference of model. + +First you need to follow EasyDeploy's [basic documentation](../../../projects/easydeploy/docs/model_convert.md) controls own equipment installed for each library. + +```shell +pip install onnx +pip install onnx-simplifier # Install if you want to use simplify +pip install tensorrt # If you have GPU environment and need to output TensorRT model you need to continue execution +``` + +Once installed, you can use the following command to transform and deploy the trained model on the cat dataset with one click. The current ONNX version is 1.13.0 and TensorRT version is 8.5.3.1, so keep the `--opset` value of 11. The remaining parameters need to be adjusted according to the config used. Here we export the CPU version of ONNX with the `--backend` set to 1. + +```shell +python projects/easydeploy/tools/export.py \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --work-dir work_dirs/yolov5_s-v61_fast_1xb12-40e_cat \ + --img-size 640 640 \ + --batch 1 \ + --device cpu \ + --simplify \ + --opset 11 \ + --backend 1 \ + --pre-topk 1000 \ + --keep-topk 100 \ + --iou-threshold 0.65 \ + --score-threshold 0.25 +``` + +On success, you will get the converted ONNX model under `work-dir`, which is named `end2end.onnx` by default. + +Let's use `end2end.onnx` model to perform a basic image inference: + +```shell +python projects/easydeploy/tools/image-demo.py \ + data/cat/images/IMG_20210728_205312.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/end2end.onnx \ + --device cpu +``` + +After successful inference, the result image will be generated in the `output` folder of the default MMYOLO root directory. If you want to see the result without saving it, you can add `--show` to the end of the above command. For convenience, the following is the generated result. + +
+image +
+ +Let's go on to convert the engine file for TensorRT, because TensorRT needs to be specific to the current environment and deployment version, so make sure to export the parameters, here we export the TensorRT8 file, the `--backend` is 2. + +```shell +python projects/easydeploy/tools/export.py \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/epoch_40.pth \ + --work-dir work_dirs/yolov5_s-v61_fast_1xb12-40e_cat \ + --img-size 640 640 \ + --batch 1 \ + --device cuda:0 \ + --simplify \ + --opset 11 \ + --backend 2 \ + --pre-topk 1000 \ + --keep-topk 100 \ + --iou-threshold 0.65 \ + --score-threshold 0.25 +``` + +The resulting `end2end.onnx` is the ONNX file for the TensorRT8 deployment, which we will use to complete the TensorRT engine transformation. + +```shell +python projects/easydeploy/tools/build_engine.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/end2end.onnx \ + --img-size 640 640 \ + --device cuda:0 +``` + +Successful execution will generate the `end2end.engine` file under `work-dir`: + +```shell +work_dirs/yolov5_s-v61_fast_1xb12-40e_cat +├── 202302XX_XXXXXX +│ ├── 202302XX_XXXXXX.log +│ └── vis_data +│ ├── 202302XX_XXXXXX.json +│ ├── config.py +│ └── scalars.json +├── best_coco +│ └── bbox_mAP_epoch_40.pth +├── end2end.engine +├── end2end.onnx +├── epoch_30.pth +├── epoch_40.pth +├── last_checkpoint +└── yolov5_s-v61_fast_1xb12-40e_cat.py +``` + +Let's continue use `image-demo.py` for image inference: + +```shell +python projects/easydeploy/tools/image-demo.py \ + data/cat/images/IMG_20210728_205312.jpg \ + configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py \ + work_dirs/yolov5_s-v61_fast_1xb12-40e_cat/end2end.engine \ + --device cuda:0 +``` + +Here we choose to save the inference results under `output` instead of displaying them directly. The following shows the inference results. + +
+image +
+ +This completes the transformation deployment of the trained model and checks the inference results. This is the end of the tutorial. + +The full content above can be viewed in [15_minutes_object_detection.ipynb](https://github.com/open-mmlab/mmyolo/blob/dev/demo/15_minutes_object_detection.ipynb). If you encounter problems during training or testing, please check the [common troubleshooting steps](../recommended_topics/troubleshooting_steps.md) first and feel free to open an [issue](https://github.com/open-mmlab/mmyolo/issues/new/choose) if you still can't solve it. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_rotated_object_detection.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_rotated_object_detection.md new file mode 100644 index 0000000000000000000000000000000000000000..6e04c8c0a8fbda5266e2cd488fc4ca584fc8cfb2 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/15_minutes_rotated_object_detection.md @@ -0,0 +1,3 @@ +# 15 minutes to get started with MMYOLO rotated object detection + +TODO diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/dependencies.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/dependencies.md new file mode 100644 index 0000000000000000000000000000000000000000..0d7fc6ad0c3c9d1295201f9cefe423928e44caec --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/dependencies.md @@ -0,0 +1,60 @@ +# Prerequisites + +Compatible MMEngine, MMCV and MMDetection versions are shown as below. Please install the correct version to avoid installation issues. + +| MMYOLO version | MMDetection version | MMEngine version | MMCV version | +| :------------: | :----------------------: | :----------------------: | :---------------------: | +| main | mmdet>=3.0.0, \<3.1.0 | mmengine>=0.7.1, \<1.0.0 | mmcv>=2.0.0rc4, \<2.1.0 | +| 0.6.0 | mmdet>=3.0.0, \<3.1.0 | mmengine>=0.7.1, \<1.0.0 | mmcv>=2.0.0rc4, \<2.1.0 | +| 0.5.0 | mmdet>=3.0.0rc6, \<3.1.0 | mmengine>=0.6.0, \<1.0.0 | mmcv>=2.0.0rc4, \<2.1.0 | +| 0.4.0 | mmdet>=3.0.0rc5, \<3.1.0 | mmengine>=0.3.1, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | +| 0.3.0 | mmdet>=3.0.0rc5, \<3.1.0 | mmengine>=0.3.1, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | +| 0.2.0 | mmdet>=3.0.0rc3, \<3.1.0 | mmengine>=0.3.1, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | +| 0.1.3 | mmdet>=3.0.0rc3, \<3.1.0 | mmengine>=0.3.1, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | +| 0.1.2 | mmdet>=3.0.0rc2, \<3.1.0 | mmengine>=0.3.0, \<1.0.0 | mmcv>=2.0.0rc0, \<2.1.0 | +| 0.1.1 | mmdet==3.0.0rc1 | mmengine>=0.1.0, \<0.2.0 | mmcv>=2.0.0rc0, \<2.1.0 | +| 0.1.0 | mmdet==3.0.0rc0 | mmengine>=0.1.0, \<0.2.0 | mmcv>=2.0.0rc0, \<2.1.0 | + +In this section, we demonstrate how to prepare an environment with PyTorch. + +MMDetection works on Linux, Windows, and macOS. It requires: + +- Python 3.7+ +- PyTorch 1.7+ +- CUDA 9.2+ +- GCC 5.4+ + +```{note} +If you are experienced with PyTorch and have already installed it, just skip this part and jump to the [next section](#installation). Otherwise, you can follow these steps for the preparation. +``` + +**Step 0.** Download and install Miniconda from the [official website](https://docs.conda.io/en/latest/miniconda.html). + +**Step 1.** Create a conda environment and activate it. + +```shell +conda create --name openmmlab python=3.8 -y +conda activate openmmlab +``` + +**Step 2.** Install PyTorch following [official commands](https://pytorch.org/get-started/locally/), e.g. + +On GPU platforms: + +```shell +conda install pytorch torchvision -c pytorch +``` + +On CPU platforms: + +```shell +conda install pytorch torchvision cpuonly -c pytorch +``` + +**Step 3.** Verify PyTorch installation + +```shell +python -c "import torch; print(torch.__version__); print(torch.cuda.is_available())" +``` + +If the GPU is used, the version information and `True` are printed; otherwise, the version information and `False` are printed. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/installation.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/installation.md new file mode 100644 index 0000000000000000000000000000000000000000..3259acfbb6f0326844a27d72275cec53e4cf6395 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/installation.md @@ -0,0 +1,131 @@ +# Installation + +## Best Practices + +**Step 0.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim). + +```shell +pip install -U openmim +mim install "mmengine>=0.6.0" +mim install "mmcv>=2.0.0rc4,<2.1.0" +mim install "mmdet>=3.0.0,<4.0.0" +``` + +If you are currently in the mmyolo project directory, you can use the following simplified commands + +```shell +cd mmyolo +pip install -U openmim +mim install -r requirements/mminstall.txt +``` + +**Note:** + +a. In MMCV-v2.x, `mmcv-full` is rename to `mmcv`, if you want to install `mmcv` without CUDA ops, you can use `mim install "mmcv-lite>=2.0.0rc1"` to install the lite version. + +b. If you would like to use `albumentations`, we suggest using `pip install -r requirements/albu.txt` or `pip install -U albumentations --no-binary qudida,albumentations`. If you simply use `pip install albumentations==1.0.1`, it will install `opencv-python-headless` simultaneously (even though you have already installed `opencv-python`). We recommended checking the environment after installing albumentation to ensure that `opencv-python` and `opencv-python-headless` are not installed at the same time, because it might cause unexpected issues if they both installed. Please refer to [official documentation](https://albumentations.ai/docs/getting_started/installation/#note-on-opencv-dependencies) for more details. + +**Step 1.** Install MMYOLO. + +Case a: If you develop and run mmdet directly, install it from source: + +```shell +git clone https://github.com/open-mmlab/mmyolo.git +cd mmyolo +# Install albumentations +pip install -r requirements/albu.txt +# Install MMYOLO +mim install -v -e . +# "-v" means verbose, or more output +# "-e" means installing a project in editable mode, +# thus any local modifications made to the code will take effect without reinstallation. +``` + +Case b: If you use MMYOLO as a dependency or third-party package, install it with MIM: + +```shell +mim install "mmyolo" +``` + +## Verify the installation + +To verify whether MMYOLO is installed correctly, we provide an inference demo. + +**Step 1.** We need to download config and checkpoint files. + +```shell +mim download mmyolo --config yolov5_s-v61_syncbn_fast_8xb16-300e_coco --dest . +``` + +The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py` and `yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth` in your current folder. + +**Step 2.** Verify the inference demo. + +Option (a). If you install MMYOLO from source, just run the following command. + +```shell +python demo/image_demo.py demo/demo.jpg \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth + +# Optional parameters +# --out-dir ./output *The detection results are output to the specified directory. When args have action --show, the script do not save results. Default: ./output +# --device cuda:0 *The computing resources used, including cuda and cpu. Default: cuda:0 +# --show *Display the results on the screen. Default: False +# --score-thr 0.3 *Confidence threshold. Default: 0.3 +``` + +You will see a new image on your `output` folder, where bounding boxes are plotted. + +Supported input types: + +- Single image, include `jpg`, `jpeg`, `png`, `ppm`, `bmp`, `pgm`, `tif`, `tiff`, `webp`. +- Folder, all image files in the folder will be traversed and the corresponding results will be output. +- URL, will automatically download from the URL and the corresponding results will be output. + +Option (b). If you install MMYOLO with MIM, open your python interpreter and copy&paste the following codes. + +```python +from mmdet.apis import init_detector, inference_detector + +config_file = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' +checkpoint_file = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' +model = init_detector(config_file, checkpoint_file, device='cpu') # or device='cuda:0' +inference_detector(model, 'demo/demo.jpg') +``` + +You will see a list of `DetDataSample`, and the predictions are in the `pred_instance`, indicating the detected bounding boxes, labels, and scores. + +## Using MMYOLO with Docker + +We provide a [Dockerfile](https://github.com/open-mmlab/mmyolo/blob/main/docker/Dockerfile) to build an image. Ensure that your [docker version](https://docs.docker.com/engine/install/) >=19.03. + +Reminder: If you find out that your download speed is very slow, we suggest canceling the comments in the last two lines of `Optional` in the [Dockerfile](https://github.com/open-mmlab/mmyolo/blob/main/docker/Dockerfile#L19-L20) to obtain a rocket like download speed: + +```dockerfile +# (Optional) +RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list && \ + pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple +``` + +Build Command： + +```shell +# build an image with PyTorch 1.9, CUDA 11.1 +# If you prefer other versions, just modified the Dockerfile +docker build -t mmyolo docker/ +``` + +Run it with: + +```shell +export DATA_DIR=/path/to/your/dataset +docker run --gpus all --shm-size=8g -it -v ${DATA_DIR}:/mmyolo/data mmyolo +``` + +For other customized inatallation, see [Customized Installation](../tutorials/custom_installation.md) + +## Troubleshooting + +If you have some issues during the installation, please first view the [FAQ](../tutorials/faq.md) page. +You may [open an issue](https://github.com/open-mmlab/mmyolo/issues/new/choose) on GitHub if no solution is found. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/overview.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/overview.md new file mode 100644 index 0000000000000000000000000000000000000000..52bcbd1716674a42e2155e27a948250777fe958f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/get_started/overview.md @@ -0,0 +1,81 @@ +# Overview + +## MMYOLO Introduction + +
+image +
+ +MMYOLO is an open-source algorithms toolkit of YOLO based on PyTorch and MMDetection, part of the [OpenMMLab](https://openmmlab.com/) project. MMYOLO is positioned as a popular open-source library of YOLO series and core library of industrial applications. Its vision diagram is shown as follows: + +
+vision diagram +
+ +The following tasks are currently supported: + +
+Tasks currently supported + +- Object detection +- Rotated object detection + +
+ +The YOLO series of algorithms currently supported are as follows: + +
+Algorithms currently supported + +- YOLOv5 +- YOLOX +- RTMDet +- RTMDet-Rotated +- YOLOv6 +- YOLOv7 +- PPYOLOE +- YOLOv8 + +
+ +The datasets currently supported are as follows: + +
+Datasets currently supported + +- COCO Dataset +- VOC Dataset +- CrowdHuman Dataset +- DOTA 1.0 Dataset + +
+ +MMYOLO runs on Linux, Windows, macOS, and supports PyTorch 1.7 or later. It has the following three characteristics: + +- 🕹️ **Unified and convenient algorithm evaluation** + + MMYOLO unifies various YOLO algorithm modules and provides a unified evaluation process, so that users can compare and analyze fairly and conveniently. + +- 📚 **Extensive documentation for started and advanced** + + MMYOLO provides a series of documents, including getting started, deployment, advanced practice and algorithm analysis, which is convenient for different users to get started and expand. + +- 🧩 **Modular Design** + + MMYOLO disentangled the framework into modular components, and users can easily build custom models by combining different modules and training and testing strategies. + +Base module-P5 + This image is provided by RangeKing@GitHub, thanks very much! + +## User guide for this documentation + +MMYOLO divides the document structure into 6 parts, corresponding to different user needs. + +- **Get started with MMYOLO**. This part is must read for first-time MMYOLO users, so please read it carefully. +- **Recommend Topics**. This part is the essence documentation provided in MMYOLO by topics, including lots of MMYOLO features, etc. Highly recommended reading for all MMYOLO users. +- **Common functions**. This part provides a list of common features that you will use during the training and testing process, so you can refer back to them when you need. +- **Useful tools**. This part is useful tools summary under `tools`, so that you can quickly and happily use the various scripts provided in MMYOLO. +- **Basic and advanced tutorials**. This part introduces some basic concepts and advanced tutorials in MMYOLO. It is suitable for users who want to understand the design idea and structure design of MMYOLO in detail. +- **Others**. The rest includes model repositories, specifications and interface documentation, etc. + +Users with different needs can choose your favorite content to read. If you have any questions about this documentation or a better idea to improve it, welcome to post a Pull Request to MMYOLO ~. Please refer to [How to Contribute to MMYOLO](../recommended_topics/contributing.md) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/index.rst b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..1a0ab6c3b3d170479f096487c21871a2e273beb4 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/index.rst @@ -0,0 +1,120 @@ +Welcome to MMYOLO's documentation! +======================================= +You can switch between Chinese and English documents in the top-right corner of the layout. + +.. toctree:: + :maxdepth: 2 + :caption: Get Started + + get_started/overview.md + get_started/dependencies.md + get_started/installation.md + get_started/15_minutes_object_detection.md + get_started/15_minutes_rotated_object_detection.md + get_started/15_minutes_instance_segmentation.md + get_started/article.md + +.. toctree:: + :maxdepth: 2 + :caption: Recommended Topics + + recommended_topics/contributing.md + recommended_topics/training_testing_tricks.md + recommended_topics/model_design.md + recommended_topics/algorithm_descriptions/index.rst + recommended_topics/application_examples/index.rst + recommended_topics/replace_backbone.md + recommended_topics/complexity_analysis.md + recommended_topics/labeling_to_deployment_tutorials.md + recommended_topics/visualization.md + recommended_topics/deploy/index.rst + recommended_topics/troubleshooting_steps.md + recommended_topics/mm_basics.md + recommended_topics/dataset_preparation.md + +.. toctree:: + :maxdepth: 2 + :caption: Common Usage + + common_usage/resume_training.md + common_usage/syncbn.md + common_usage/amp_training.md + common_usage/ms_training_testing.md + common_usage/tta.md + common_usage/plugins.md + common_usage/freeze_layers.md + common_usage/output_predictions.md + common_usage/set_random_seed.md + common_usage/module_combination.md + common_usage/mim_usage.md + common_usage/multi_necks.md + common_usage/specify_device.md + common_usage/single_multi_channel_applications.md + + +.. toctree:: + :maxdepth: 2 + :caption: Useful Tools + + useful_tools/browse_coco_json.md + useful_tools/browse_dataset.md + useful_tools/print_config.md + useful_tools/dataset_analysis.md + useful_tools/optimize_anchors.md + useful_tools/extract_subcoco.md + useful_tools/vis_scheduler.md + useful_tools/dataset_converters.md + useful_tools/download_dataset.md + useful_tools/log_analysis.md + useful_tools/model_converters.md + +.. toctree:: + :maxdepth: 2 + :caption: Basic Tutorials + + tutorials/config.md + tutorials/data_flow.md + tutorials/custom_installation.md + tutorials/warning_notes.md + tutorials/faq.md + + +.. toctree:: + :maxdepth: 2 + :caption: Advanced Tutorials + + advanced_guides/cross-library_application.md + + +.. toctree:: + :maxdepth: 2 + :caption: Model Zoo + + model_zoo.md + +.. toctree:: + :maxdepth: 1 + :caption: Notes + + notes/changelog.md + notes/compatibility.md + notes/conventions.md + notes/code_style.md + +.. toctree:: + :maxdepth: 1 + :caption: API Reference + + api.rst + +.. toctree:: + :caption: Switch Language + + switch_language.md + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`search` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/make.bat b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/make.bat new file mode 100644 index 0000000000000000000000000000000000000000..922152e96a04a242e6fc40f124261d74890617d8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/model_zoo.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/model_zoo.md new file mode 100644 index 0000000000000000000000000000000000000000..1547bb9d090c3f7aa65c2c1a39ae10fa096cb0f8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/model_zoo.md @@ -0,0 +1,94 @@ +# Model Zoo and Benchmark + +This page is used to summarize the performance and related evaluation metrics of various models supported in MMYOLO for users to compare and analyze. + +## COCO dataset + +
+ +
+ +| Model | Arch | Size | Batch Size | Epoch | SyncBN | AMP | Mem (GB) | Params(M) | FLOPs(G) | TRT-FP16-GPU-Latency(ms) | Box AP | TTA Box AP | +| :--------------: | :--: | :--: | :--------: | :---: | :----: | :-: | :------: | :-------: | :------: | :----------------------: | :----: | :--------: | +| YOLOv5-n | P5 | 640 | 8xb16 | 300 | Yes | Yes | 1.5 | 1.87 | 2.26 | 1.14 | 28.0 | 30.7 | +| YOLOv6-v2.0-n | P5 | 640 | 8xb32 | 400 | Yes | Yes | 6.04 | 4.32 | 5.52 | 1.37 | 36.2 | | +| YOLOv8-n | P5 | 640 | 8xb16 | 500 | Yes | Yes | 2.5 | 3.16 | 4.4 | 1.53 | 37.4 | 39.9 | +| RTMDet-tiny | P5 | 640 | 8xb32 | 300 | Yes | No | 11.9 | 4.90 | 8.09 | 2.31 | 41.8 | 43.2 | +| YOLOv6-v2.0-tiny | P5 | 640 | 8xb32 | 400 | Yes | Yes | 8.13 | 9.70 | 12.37 | 2.19 | 41.0 | | +| YOLOv7-tiny | P5 | 640 | 8xb16 | 300 | Yes | Yes | 2.7 | 6.23 | 6.89 | 1.88 | 37.5 | | +| YOLOX-tiny | P5 | 416 | 8xb32 | 300 | No | Yes | 4.9 | 5.06 | 7.63 | 1.19 | 34.3 | | +| RTMDet-s | P5 | 640 | 8xb32 | 300 | Yes | No | 16.3 | 8.89 | 14.84 | 2.89 | 45.7 | 47.3 | +| YOLOv5-s | P5 | 640 | 8xb16 | 300 | Yes | Yes | 2.7 | 7.24 | 8.27 | 1.89 | 37.7 | 40.2 | +| YOLOv6-v2.0-s | P5 | 640 | 8xb32 | 400 | Yes | Yes | 8.88 | 17.22 | 21.94 | 2.67 | 44.0 | | +| YOLOv8-s | P5 | 640 | 8xb16 | 500 | Yes | Yes | 4.0 | 11.17 | 14.36 | 2.61 | 45.1 | 46.8 | +| YOLOX-s | P5 | 640 | 8xb32 | 300 | No | Yes | 9.8 | 8.97 | 13.40 | 2.38 | 41.9 | | +| PPYOLOE+ -s | P5 | 640 | 8xb8 | 80 | Yes | No | 4.7 | 7.93 | 8.68 | 2.54 | 43.5 | | +| RTMDet-m | P5 | 640 | 8xb32 | 300 | Yes | No | 29.0 | 24.71 | 39.21 | 6.23 | 50.2 | 51.9 | +| YOLOv5-m | P5 | 640 | 8xb16 | 300 | Yes | Yes | 5.0 | 21.19 | 24.53 | 4.28 | 45.3 | 46.9 | +| YOLOv6-v2.0-m | P5 | 640 | 8xb32 | 300 | Yes | Yes | 16.69 | 34.25 | 40.7 | 5.12 | 48.4 | | +| YOLOv8-m | P5 | 640 | 8xb16 | 500 | Yes | Yes | 7.0 | 25.9 | 39.57 | 5.78 | 50.6 | 52.3 | +| YOLOX-m | P5 | 640 | 8xb32 | 300 | No | Yes | 17.6 | 25.33 | 36.88 | 5.31 | 47.5 | | +| PPYOLOE+ -m | P5 | 640 | 8xb8 | 80 | Yes | No | 8.4 | 23.43 | 24.97 | 5.47 | 49.5 | | +| RTMDet-l | P5 | 640 | 8xb32 | 300 | Yes | No | 45.2 | 52.32 | 80.12 | 10.13 | 52.3 | 53.7 | +| YOLOv5-l | P5 | 640 | 8xb16 | 300 | Yes | Yes | 8.1 | 46.56 | 54.65 | 6.8 | 48.8 | 49.9 | +| YOLOv6-v2.0-l | P5 | 640 | 8xb32 | 300 | Yes | Yes | 20.86 | 58.53 | 71.43 | 8.78 | 51.0 | | +| YOLOv7-l | P5 | 640 | 8xb16 | 300 | Yes | Yes | 10.3 | 36.93 | 52.42 | 6.63 | 50.9 | | +| YOLOv8-l | P5 | 640 | 8xb16 | 500 | Yes | Yes | 9.1 | 43.69 | 82.73 | 8.97 | 53.0 | 54.4 | +| YOLOX-l | P5 | 640 | 8xb8 | 300 | No | Yes | 8.0 | 54.21 | 77.83 | 9.23 | 50.1 | | +| PPYOLOE+ -l | P5 | 640 | 8xb8 | 80 | Yes | No | 13.2 | 52.20 | 55.05 | 8.2 | 52.6 | | +| RTMDet-x | P5 | 640 | 8xb32 | 300 | Yes | No | 63.4 | 94.86 | 145.41 | 17.89 | 52.8 | 54.2 | +| YOLOv7-x | P5 | 640 | 8xb16 | 300 | Yes | Yes | 13.7 | 71.35 | 95.06 | 11.63 | 52.8 | | +| YOLOv8-x | P5 | 640 | 8xb16 | 500 | Yes | Yes | 12.4 | 68.23 | 132.10 | 14.22 | 54.0 | 55.0 | +| YOLOX-x | P5 | 640 | 8xb8 | 300 | No | Yes | 9.8 | 99.07 | 144.39 | 15.35 | 51.4 | | +| PPYOLOE+ -x | P5 | 640 | 8xb8 | 80 | Yes | No | 19.1 | 98.42 | 105.48 | 14.02 | 54.2 | | +| YOLOv5-n | P6 | 1280 | 8xb16 | 300 | Yes | Yes | 5.8 | 3.25 | 2.30 | | 35.9 | | +| YOLOv5-s | P6 | 1280 | 8xb16 | 300 | Yes | Yes | 10.5 | 12.63 | 8.45 | | 44.4 | | +| YOLOv5-m | P6 | 1280 | 8xb16 | 300 | Yes | Yes | 19.1 | 35.73 | 25.05 | | 51.3 | | +| YOLOv5-l | P6 | 1280 | 8xb16 | 300 | Yes | Yes | 30.5 | 76.77 | 55.77 | | 53.7 | | +| YOLOv7-w | P6 | 1280 | 8xb16 | 300 | Yes | Yes | 27.0 | 82.31 | 45.07 | | 54.1 | | +| YOLOv7-e | P6 | 1280 | 8xb16 | 300 | Yes | Yes | 42.5 | 114.69 | 64.48 | | 55.1 | | + +- All the models are trained on COCO train2017 dataset and evaluated on val2017 dataset. +- TRT-FP16-GPU-Latency(ms) is the GPU Compute time on NVIDIA Tesla T4 device with TensorRT 8.4, a batch size of 1, a test shape of 640x640 and only model forward (The test shape for YOLOX-tiny is 416x416) +- The number of model parameters and FLOPs are obtained using the [get_flops](https://github.com/open-mmlab/mmyolo/blob/dev/tools/analysis_tools/get_flops.py) script. Different calculation methods may vary slightly +- RTMDet performance is the result of training with [MMRazor Knowledge Distillation](https://github.com/open-mmlab/mmyolo/blob/dev/configs/rtmdet/distillation/README.md) +- Only YOLOv6 version 2.0 is implemented in MMYOLO for now, and L and M are the results without knowledge distillation +- YOLOv8 results are optimized using mask instance annotation, but YOLOv5, YOLOv6 and YOLOv7 do not use +- PPYOLOE+ uses Obj365 as pre-training weights, so the number of epochs for COCO training only needs 80 +- YOLOX-tiny, YOLOX-s and YOLOX-m are trained with the optimizer parameters proposed in RTMDet, with different degrees of performance improvement compared to the original implementation. + +Please see below items for more details + +- [RTMDet](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet) +- [YOLOv5](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5) +- [YOLOv6](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov6) +- [YOLOv7](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov7) +- [YOLOv8](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov8) +- [YOLOX](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolox) +- [PPYOLO-E](https://github.com/open-mmlab/mmyolo/blob/main/configs/ppyoloe) + +## VOC dataset + +| Backbone | size | Batchsize | AMP | Mem (GB) | box AP(COCO metric) | +| :------: | :--: | :-------: | :-: | :------: | :-----------------: | +| YOLOv5-n | 512 | 64 | Yes | 3.5 | 51.2 | +| YOLOv5-s | 512 | 64 | Yes | 6.5 | 62.7 | +| YOLOv5-m | 512 | 64 | Yes | 12.0 | 70.1 | +| YOLOv5-l | 512 | 32 | Yes | 10.0 | 73.1 | + +Please see below items for more details + +- [YOLOv5](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5) + +## CrowdHuman dataset + +| Backbone | size | SyncBN | AMP | Mem (GB) | ignore_iof_thr | box AP50(CrowDHuman Metric) | MR | JI | +| :------: | :--: | :----: | :-: | :------: | :------------: | :-------------------------: | :--: | :---: | +| YOLOv5-s | 640 | Yes | Yes | 2.6 | -1 | 85.79 | 48.7 | 75.33 | +| YOLOv5-s | 640 | Yes | Yes | 2.6 | 0.5 | 86.17 | 48.8 | 75.87 | + +Please see below items for more details + +- [YOLOv5](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5) + +## DOTA 1.0 dataset diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/changelog.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/changelog.md new file mode 100644 index 0000000000000000000000000000000000000000..fa3e1a776423df5c5a05d36870350e5b2fcd0bb1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/changelog.md @@ -0,0 +1,342 @@ +# Changelog + +## v0.6.0 (15/8/2023) + +### Highlights + +- Support YOLOv5 instance segmentation +- Support YOLOX-Pose based on MMPose +- Add 15 minutes instance segmentation tutorial. +- YOLOv5 supports using mask annotation to optimize bbox +- Add Multi-scale training and testing docs + +### New Features + +- Add training and testing tricks doc (#659) +- Support setting the cache_size_limit parameter and support mmdet 3.0.0 (#707) +- Support YOLOv5u and YOLOv6 3.0 inference (#624, #744) +- Support model-only inference (#733) +- Add YOLOv8 deepstream config (#633) +- Add ionogram example in MMYOLO application (#643) + +### Bug Fixes + +- Fix the browse_dataset for visualization of test and val (#641) +- Fix installation doc error (#662) +- Fix yolox-l ckpt link (#677) +- Fix typos in the YOLOv7 and YOLOv8 diagram (#621, #710) +- Adjust the order of package imports in `boxam_vis_demo.py` (#655) + +### Improvements + +- Optimize the `convert_kd_ckpt_to_student.py` file (#647) +- Add en doc of `FAQ` and `training_testing_tricks` (#691,#693) + +### Contributors + +A total of 21 developers contributed to this release. + +Thank @Lum1104,@azure-wings,@FeiGeChuanShu,@Lingrui Gu,@Nioolek,@huayuan4396,@RangeKing,@danielhonies,@yechenzhi,@JosonChan1998,@kitecats,@Qingrenn,@triple-Mu,@kikefdezl,@zhangrui-wolf,@xin-li-67,@Ben-Louis,@zgzhengSEU,@VoyagerXvoyagerx,@tang576225574,@hhaAndroid + +## v0.5.0 (2/3/2023) + +### Highlights + +1. Support [RTMDet-R](https://github.com/open-mmlab/mmyolo/blob/dev/configs/rtmdet/README.md#rotated-object-detection) rotated object detection +2. Support for using mask annotation to improve [YOLOv8](https://github.com/open-mmlab/mmyolo/blob/dev/configs/yolov8/README.md) object detection performance +3. Support [MMRazor](https://github.com/open-mmlab/mmyolo/blob/dev/configs/razor/subnets/README.md) searchable NAS sub-network as the backbone of YOLO series algorithm +4. Support calling [MMRazor](https://github.com/open-mmlab/mmyolo/blob/dev/configs/rtmdet/distillation/README.md) to distill the knowledge of RTMDet +5. [MMYOLO](https://mmyolo.readthedocs.io/zh_CN/dev/) document structure optimization, comprehensive content upgrade +6. Improve YOLOX mAP and training speed based on RTMDet training hyperparameters +7. Support calculation of model parameters and FLOPs, provide GPU latency data on T4 devices, and update [Model Zoo](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/model_zoo.md) +8. Support test-time augmentation (TTA) +9. Support RTMDet, YOLOv8 and YOLOv7 assigner visualization + +### New Features + +01. Support inference for RTMDet instance segmentation tasks (#583) +02. Beautify the configuration file in MMYOLO and add more comments (#501, #506, #516, #529, #531, #539) +03. Refactor and optimize documentation (#568, #573, #579, #584, #587, #589, #596, #599, #600) +04. Support fast version of YOLOX (#518) +05. Support DeepStream in EasyDeploy and add documentation (#485, #545, #571) +06. Add confusion matrix drawing script (#572) +07. Add single channel application case (#460) +08. Support auto registration (#597) +09. Support Box CAM of YOLOv7, YOLOv8 and PPYOLOE (#601) +10. Add automated generation of MM series repo registration information and tools scripts (#559) +11. Added YOLOv7 model structure diagram (#504) +12. Add how to specify specific GPU training and inference files (#503) +13. Add check if `metainfo` is all lowercase when training or testing (#535) +14. Add links to Twitter, Discord, Medium, YouTube, etc. (#555) + +### Bug Fixes + +1. Fix isort version issue (#492, #497) +2. Fix type error of assigner visualization (#509) +3. Fix YOLOv8 documentation link error (#517) +4. Fix RTMDet Decoder error in EasyDeploy (#519) +5. Fix some document linking errors (#537) +6. Fix RTMDet-Tiny weight path error (#580) + +### Improvements + +1. Update `contributing.md` +2. Optimize `DetDataPreprocessor` branch to support multitasking (#511) +3. Optimize `gt_instances_preprocess` so it can be used for other YOLO algorithms (#532) +4. Add `yolov7-e6e` weight conversion script (#570) +5. Reference YOLOv8 inference code modification PPYOLOE + +### Contributors + +A total of 22 developers contributed to this release. + +Thank @triple-Mu, @isLinXu, @Audrey528, @TianWen580, @yechenzhi, @RangeKing, @lyviva, @Nioolek, @PeterH0323, @tianleiSHI, @aptsunny, @satuoqaq, @vansin, @xin-li-67, @VoyagerXvoyagerx, +@landhill, @kitecats, @tang576225574, @HIT-cwh, @AI-Tianlong, @RangiLyu, @hhaAndroid + +## v0.4.0 (18/1/2023) + +### Highlights + +1. Implemented [YOLOv8](https://github.com/open-mmlab/mmyolo/blob/dev/configs/yolov8/README.md) object detection model, and supports model deployment in [projects/easydeploy](https://github.com/open-mmlab/mmyolo/blob/dev/projects/easydeploy) +2. Added Chinese and English versions of [Algorithm principles and implementation with YOLOv8](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/algorithm_descriptions/yolov8_description.md) + +### New Features + +1. Added YOLOv8 and PPYOLOE model structure diagrams (#459, #471) +2. Adjust the minimum supported Python version from 3.6 to 3.7 (#449) +3. Added a new YOLOX decoder in TensorRT-8 (#450) +4. Add a tool for scheduler visualization (#479) + +### Bug Fixes + +1. Fix `optimize_anchors.py` script import error (#452) +2. Fix the wrong installation steps in `get_started.md` (#474) +3. Fix the neck error when using the `RTMDet` P6 model (#480) + +### Contributors + +A total of 9 developers contributed to this release. + +Thank @VoyagerXvoyagerx, @tianleiSHI, @RangeKing, @PeterH0323, @Nioolek, @triple-Mu, @lyviva, @Zheng-LinXiao, @hhaAndroid + +## v0.3.0 (8/1/2023) + +### Highlights + +1. Implement fast version of [RTMDet](https://github.com/open-mmlab/mmyolo/blob/dev/configs/rtmdet/README.md). RTMDet-s 8xA100 training takes only 14 hours. The training speed is 2.6 times faster than the previous version. +2. Support [PPYOLOE](https://github.com/open-mmlab/mmyolo/blob/dev/configs/ppyoloe/README.md) training +3. Support `iscrowd` attribute training in [YOLOv5](https://github.com/open-mmlab/mmyolo/blob/dev/configs/yolov5/crowdhuman/yolov5_s-v61_8xb16-300e_ignore_crowdhuman.py) +4. Support [YOLOv5 assigner result visualization](https://github.com/open-mmlab/mmyolo/blob/dev/projects/assigner_visualization/README.md) + +### New Features + +01. Add `crowdhuman` dataset (#368) +02. Easydeploy support TensorRT inference (#377) +03. Add `YOLOX` structure description (#402) +04. Add a feature for the video demo (#392) +05. Support `YOLOv7` easy deploy (#427) +06. Add resume from specific checkpoint in CLI (#393) +07. Set `metainfo` fields to lower case (#362, #412) +08. Add module combination doc (#349, #352, #345) +09. Add docs about how to freeze the weight of backbone or neck (#418) +10. Add don't used pre-training weights doc in `how_to.md` (#404) +11. Add docs about how to set the random seed (#386) +12. Translate `rtmdet_description.md` document to English (#353) +13. Add doc of `yolov6_description.md` (#382, #372) + +### Bug Fixes + +01. Fix bugs in the output annotation file when `--class-id-txt` is set (#430) +02. Fix batch inference bug in `YOLOv5` head (#413) +03. Fix typehint in some heads (#415, #416, #443) +04. Fix RuntimeError of `torch.cat()` expected a non-empty list of Tensors (#376) +05. Fix the device inconsistency error in `YOLOv7` training (#397) +06. Fix the `scale_factor` and `pad_param` value in `LetterResize` (#387) +07. Fix docstring graph rendering error of readthedocs (#400) +08. Fix AssertionError when `YOLOv6` from training to val (#378) +09. Fix CI error due to `np.int` and legacy builder.py (#389) +10. Fix MMDeploy rewriter (#366) +11. Fix MMYOLO unittest scope bug (#351) +12. Fix `pad_param` error (#354) +13. Fix twice head inference bug (#342) +14. Fix customize dataset training (#428) + +### Improvements + +01. Update `useful_tools.md` (#384) +02. update the English version of `custom_dataset.md` (#381) +03. Remove context argument from the rewriter function (#395) +04. deprecating `np.bool` type alias (#396) +05. Add new video link for custom dataset (#365) +06. Export onnx for model only (#361) +07. Add MMYOLO regression test yml (#359) +08. Update video tutorials in `article.md` (#350) +09. Add deploy demo (#343) +10. Optimize the vis results of large images in debug mode (#346) +11. Improve args for `browse_dataset` and support `RepeatDataset` (#340, #338) + +### Contributors + +A total of 28 developers contributed to this release. + +Thank @RangeKing, @PeterH0323, @Nioolek, @triple-Mu, @matrixgame2018, @xin-li-67, @tang576225574, @kitecats, @Seperendity, @diplomatist, @vaew, @wzr-skn, @VoyagerXvoyagerx, @MambaWong, @tianleiSHI, @caj-github, @zhubochao, @lvhan028, @dsghaonan, @lyviva, @yuewangg, @wang-tf, @satuoqaq, @grimoire, @RunningLeon, @hanrui1sensetime, @RangiLyu, @hhaAndroid + +## v0.2.0（1/12/2022) + +### Highlights + +1. Support [YOLOv7](https://github.com/open-mmlab/mmyolo/tree/dev/configs/yolov7) P5 and P6 model +2. Support [YOLOv6](https://github.com/open-mmlab/mmyolo/blob/dev/configs/yolov6/README.md) ML model +3. Support [Grad-Based CAM and Grad-Free CAM](https://github.com/open-mmlab/mmyolo/blob/dev/demo/boxam_vis_demo.py) +4. Support [large image inference](https://github.com/open-mmlab/mmyolo/blob/dev/demo/large_image_demo.py) based on sahi +5. Add [easydeploy](https://github.com/open-mmlab/mmyolo/blob/dev/projects/easydeploy/README.md) project under the projects folder +6. Add [custom dataset guide](https://github.com/open-mmlab/mmyolo/blob/dev/docs/zh_cn/user_guides/custom_dataset.md) + +### New Features + +1. `browse_dataset.py` script supports visualization of original image, data augmentation and intermediate results (#304) +2. Add flag to output labelme label file in `image_demo.py` (#288, #314) +3. Add `labelme2coco` script (#308, #313) +4. Add split COCO dataset script (#311) +5. Add two examples of backbone replacement in `how-to.md` and update `plugin.md` (#291) +6. Add `contributing.md` and `code_style.md` (#322) +7. Add docs about how to use mim to run scripts across libraries (#321) +8. Support `YOLOv5` deployment at RV1126 device (#262) + +### Bug Fixes + +1. Fix MixUp padding error (#319) +2. Fix scale factor order error of `LetterResize` and `YOLOv5KeepRatioResize` (#305) +3. Fix training errors of `YOLOX Nano` model (#285) +4. Fix `RTMDet` deploy error (#287) +5. Fix int8 deploy config (#315) +6. Fix `make_stage_plugins` doc in `basebackbone` (#296) +7. Enable switch to deploy when create pytorch model in deployment (#324) +8. Fix some errors in `RTMDet` model graph (#317) + +### Improvements + +1. Add option of json output in `test.py` (#316) +2. Add area condition in `extract_subcoco.py` script (#286) +3. Deployment doc translation (#289) +4. Add YOLOv6 description overview doc (#252) +5. Improve `config.md` (#297, #303) + 6Add mosaic9 graph in docstring (#307) +6. Improve `browse_coco_json.py` script args (#309) +7. Refactor some functions in `dataset_analysis.py` to be more general (#294) + +#### Contributors + +A total of 14 developers contributed to this release. + +Thank @fcakyon, @matrixgame2018, @MambaWong, @imAzhou, @triple-Mu, @RangeKing, @PeterH0323, @xin-li-67, @kitecats, @hanrui1sensetime, @AllentDan, @Zheng-LinXiao, @hhaAndroid, @wanghonglie + +## v0.1.3（10/11/2022) + +### New Features + +1. Support CBAM plug-in and provide plug-in documentation (#246) +2. Add YOLOv5 P6 model structure diagram and related descriptions (#273) + +### Bug Fixes + +1. Fix training failure when saving best weights based on mmengine 0.3.1 +2. Fix `add_dump_metric` error based on mmdet 3.0.0rc3 (#253) +3. Fix backbone does not support `init_cfg` issue (#272) +4. Change typing import method based on mmdet 3.0.0rc3 (#261) + +### Improvements + +1. `featmap_vis_demo` support for folder and url input (#248) +2. Deploy docker file refinement (#242) + +#### Contributors + +A total of 10 developers contributed to this release. + +Thank @kitecats, @triple-Mu, @RangeKing, @PeterH0323, @Zheng-LinXiao, @tkhe, @weikai520, @zytx121, @wanghonglie, @hhaAndroid + +## v0.1.2（3/11/2022) + +### Highlights + +1. Support [YOLOv5/YOLOv6/YOLOX/RTMDet deployments](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy) for ONNXRuntime and TensorRT +2. Support [YOLOv6](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov6) s/t/n model training +3. YOLOv5 supports [P6 model training which can input 1280-scale images](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5) +4. YOLOv5 supports [VOC dataset training](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/voc) +5. Support [PPYOLOE](https://github.com/open-mmlab/mmyolo/blob/main/configs/ppyoloe) and [YOLOv7](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov7) model inference and official weight conversion +6. Add YOLOv5 replacement [backbone tutorial](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/advanced_guides/how_to.md#use-backbone-network-implemented-in-other-openmmlab-repositories) in How-to documentation + +### New Features + +1. Add `optimize_anchors` script (#175) +2. Add `extract_subcoco` script (#186) +3. Add `yolo2coco` conversion script (#161) +4. Add `dataset_analysis` script (#172) +5. Remove Albu version restrictions (#187) + +### Bug Fixes + +1. Fix the problem that `cfg.resume` does not work when set (#221) +2. Fix the problem of not showing bbox in feature map visualization script (#204) +3. uUpdate the metafile of RTMDet (#188) +4. Fix a visualization error in `test_pipeline` (#166) +5. Update badges (#140) + +### Improvements + +1. Optimize Readthedoc display page (#209) +2. Add docstring for module structure diagram for base model (#196) +3. Support for not including any instance logic in LoadAnnotations (#161) +4. Update `image_demo` script to support folder and url paths (#128) +5. Update pre-commit hook (#129) + +### Documentation + +1. Translate `yolov5_description.md`, `yolov5_tutorial.md` and `visualization.md` into English (#138, #198, #206) +2. Add deployment-related Chinese documentation (#220) +3. Update `config.md`, `faq.md` and `pull_request_template.md` (#190, #191, #200) +4. Update the `article` page (#133) + +#### Contributors + +A total of 14 developers contributed to this release. + +Thank @imAzhou, @triple-Mu, @RangeKing, @PeterH0323, @xin-li-67, @Nioolek, @kitecats, @Bin-ze, @JiayuXu0, @cydiachen, @zhiqwang, @Zheng-LinXiao, @hhaAndroid, @wanghonglie + +## v0.1.1（29/9/2022) + +Based on MMDetection's RTMDet high precision and low latency object detection algorithm, we have also released RTMDet and provided a Chinese document on the principle and implementation of RTMDet. + +### Highlights + +1. Support [RTMDet](https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet) +2. Support for backbone customization plugins and update How-to documentation (#75) + +### Bug Fixes + +1. Fix some documentation errors (#66, #72, #76, #83, #86) +2. Fix checkpoints link error (#63) +3. Fix the bug that the output of `LetterResize` does not meet the expectation when using `imscale` (#105) + +### Improvements + +1. Reducing the size of docker images (#67) +2. Simplifying `Compose` Logic in `BaseMixImageTransform` (#71) +3. Supports dump results in `test.py` (#84) + +#### Contributors + +A total of 13 developers contributed to this release. + +Thank @wanghonglie, @hhaAndroid, @yang-0201, @PeterH0323, @RangeKing, @satuoqaq, @Zheng-LinXiao, @xin-li-67, @suibe-qingtian, @MambaWong, @MichaelCai0912, @rimoire, @Nioolek + +## v0.1.0（21/9/2022) + +We have released MMYOLO open source library, which is based on MMEngine, MMCV 2.x and MMDetection 3.x libraries. At present, the object detection has been realized, and it will be expanded to multi-task in the future. + +### Highlights + +1. Support YOLOv5/YOLOX training, support YOLOv6 inference. Deployment will be supported soon. +2. Refactored YOLOX from MMDetection to accelerate training and inference. +3. Detailed introduction and advanced tutorials are provided, see the [English tutorial](https://mmyolo.readthedocs.io/en/latest). diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/code_style.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/code_style.md new file mode 100644 index 0000000000000000000000000000000000000000..3bc8291e24cdc998a0a412ec8b70ba23be4821b8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/code_style.md @@ -0,0 +1,3 @@ +# Code Style + +Coming soon. Please refer to [chinese documentation](https://mmyolo.readthedocs.io/zh_CN/latest/community/code_style.html). diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/compatibility.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/compatibility.md new file mode 100644 index 0000000000000000000000000000000000000000..7e6ad3da3e116d055d7cc5d7039fad8a9ecdaee6 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/compatibility.md @@ -0,0 +1,46 @@ +# Compatibility of MMYOLO + +## MMYOLO 0.3.0 + +### METAINFO modification + +To unify with other OpenMMLab repositories, change all keys of `METAINFO` in Dataset from upper case to lower case. + +| Before v0.3.0 | after v0.3.0 | +| :-----------: | :----------: | +| CLASSES | classes | +| PALETTE | palette | +| DATASET_TYPE | dataset_type | + +### About the order of image shape + +In OpenMMLab 2.0, to be consistent with the input argument of OpenCV, the argument about image shape in the data transformation pipeline is always in the `(width, height)` order. On the contrary, for computation convenience, the order of the field going through the data pipeline and the model is `(height, width)`. Specifically, in the results processed by each data transform pipeline, the fields and their value meaning is as below: + +- img_shape: (height, width) +- ori_shape: (height, width) +- pad_shape: (height, width) +- batch_input_shape: (height, width) + +As an example, the initialization arguments of `Mosaic` are as below: + +```python +@TRANSFORMS.register_module() +class Mosaic(BaseTransform): + def __init__(self, + img_scale: Tuple[int, int] = (640, 640), + center_ratio_range: Tuple[float, float] = (0.5, 1.5), + bbox_clip_border: bool = True, + pad_val: float = 114.0, + prob: float = 1.0) -> None: + ... + + # img_scale order should be (width, height) + self.img_scale = img_scale + + def transform(self, results: dict) -> dict: + ... + + results['img'] = mosaic_img + # (height, width) + results['img_shape'] = mosaic_img.shape[:2] +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/conventions.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/conventions.md new file mode 100644 index 0000000000000000000000000000000000000000..40ca991c6cb845df4ee6f5a9a879bf6ff1d58765 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/notes/conventions.md @@ -0,0 +1,36 @@ +# Conventions + +Please check the following conventions if you would like to modify MMYOLO as your own project. + +## About the order of image shape + +In OpenMMLab 2.0, to be consistent with the input argument of OpenCV, the argument about image shape in the data transformation pipeline is always in the `(width, height)` order. On the contrary, for computation convenience, the order of the field going through the data pipeline and the model is `(height, width)`. Specifically, in the results processed by each data transform pipeline, the fields and their value meaning is as below: + +- img_shape: (height, width) +- ori_shape: (height, width) +- pad_shape: (height, width) +- batch_input_shape: (height, width) + +As an example, the initialization arguments of `Mosaic` are as below: + +```python +@TRANSFORMS.register_module() +class Mosaic(BaseTransform): + def __init__(self, + img_scale: Tuple[int, int] = (640, 640), + center_ratio_range: Tuple[float, float] = (0.5, 1.5), + bbox_clip_border: bool = True, + pad_val: float = 114.0, + prob: float = 1.0) -> None: + ... + + # img_scale order should be (width, height) + self.img_scale = img_scale + + def transform(self, results: dict) -> dict: + ... + + results['img'] = mosaic_img + # (height, width) + results['img_shape'] = mosaic_img.shape[:2] +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/index.rst b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..e51d04cb36c92e88976c201ffb2a543987eb717f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/index.rst @@ -0,0 +1,9 @@ +Algorithm principles and implementation +****************************************** + +.. toctree:: + :maxdepth: 1 + + yolov5_description.md + yolov8_description.md + rtmdet_description.md diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/rtmdet_description.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/rtmdet_description.md new file mode 100644 index 0000000000000000000000000000000000000000..1cd62828341bc78a67255c1e807992a24d3f82b9 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/rtmdet_description.md @@ -0,0 +1,191 @@ +# Algorithm principles and implementation with RTMDet + +## 0 Introduction + +High performance, low latency one-stage object detection + +
+RTMDet_structure_v1.3 +
+ +RangeKing@github provides the graph above. Thanks, RangeKing! + +Recently,the open-source community has spring up a large number of high-precision object detection projects, one of the most prominent projects is YOLO series. OpenMMLab has also launched MMYOLO in collaboration with the community. +After investigating many improved models in current YOLO series, MMDetection core developers empirically summarized these designs and training methods, and optimized them to launch a single-stage object detector with high accuracy and low latency RTMDet, **R**eal-**t**ime **M**odels for Object **Det**ection +(**R**elease **t**o **M**anufacture) + +RTMDet consists of a series of tiny/s/m/l/x models of different sizes, which provide different choices for different application scenarios. +Specifically, RTMDet-x achieves a 300+ FPS inference speed with an accuracy of 52.6 mAP. + +```{note} +Note: Inference speed and accuracy test (excluding NMS) were performed on `TensorRT 8.4.3, cuDNN 8.2.0, FP16, batch size=1` on 1 NVIDIA 3090 GPU. +``` + +The lightest model, RTMDet-tiny, can achieve 40.9 mAP with only 4M parameters and inference speed \< 1 ms. + +
+RTMDet_accuracy_graph +
+ +The accuracy in this figure is a fair comparison to 300 training epochs, without distillation. + +| | mAP | Params | Flops | Inference speed | +| -------------------------- | --------------- | -------------- | ------------ | --------------- | +| Baseline(YOLOX) | 40.2 | 9M | 13.4G | 1.2ms | +| + AdamW + Flat Cosine | 40.6 (+0.4) | 9M | 13.4G | 1.2ms | +| + CSPNeXt backbone & PAFPN | 41.8 (+1.2) | 10.07M (+1.07) | 14.8G (+1.4) | 1.22ms (+0.02) | +| + SepBNHead | 41.8 (+0) | 8.89M (-1.18) | 14.8G | 1.22ms | +| + Label Assign & Loss | 42.9 (+1.1) | 8.89M | 14.8G | 1.22ms | +| + Cached Mosaic & MixUp | 44.2 (+1.3) | 8.89M | 14.8G | 1.22ms | +| + RSB-pretrained backbone | **44.5 (+0.3)** | 8.89M | 14.8G | 1.22ms | + +- Official repository: https://github.com/open-mmlab/mmdetection/blob/3.x/configs/rtmdet/README.md +- MMYOLO repository: https://github.com/open-mmlab/mmyolo/blob/main/configs/rtmdet/README.md + +## 1 v1.0 algorithm principle and MMYOLO implementation analysis + +### 1.1 Data augmentation + +Many data augmentation methods are used in RTMDet, mainly include single image data augmentation: + +- **RandomResize** +- **RandomCrop** +- **HSVRandomAug** +- **RandomFlip** + +and mixed image data augmentation: + +- **Mosaic** +- **MixUp** + +The following picture demonstrates the data augmentation process: + +
+image +
+ +The RandomResize hyperparameters are different on the large models M,L,X and the small models S, Tiny. Due to the number of parameters,the large models can use the `large jitter scale strategy` with parameters of (0.1,2.0). The small model adopts the `stand scale jitter` strategy with parameters of (0.5, 2.0). + +The single image data augmentation has been packaged in `MMDetection` so users can directly use all methods through simple configurations. As a very ordinary and common processing method, this part will not be further introduced now. The implementation of mixed image data augmentation is described in the following. + +Unlike YOLOv5, which considers the use of MixUp on S and Nano models is excessive. Small models don't need such strong data augmentation. However, RTMDet also uses MixUp on S and Tiny, because RTMDet will switch to normal aug at last 20 epochs, and this operation was proved to be effective by training. Moreover, RTMDet introduces a Cache scheme for mixed image data augmentation, which effectively reduces the image processing time and introduces adjustable hyperparameters. + +`max_cached_images`, which is similar to `repeated augmentation` when using a smaller cache. The details are as follows: + +| | Use cache | ms / 100 imgs | +| ------ | --------- | ------------- | +| Mosaic | | 87.1 | +| Mosaic | √ | **24.0** | +| MixUp | | 19.3 | +| MixUp | √ | **12.4** | + +| | RTMDet-s | RTMDet-l | +| ----------------------------- | -------- | -------- | +| Mosaic + MixUp + 20e finetune | 43.9 | **51.3** | + +#### 1.1.1 Introducing Cache for mixins data augmentation + +Mosaic&MixUp needs to blend multiple images, which takes k times longer than common data augmentation (k is the number of images mixed in). For example, in YOLOv5, every time Mosaic is done, the information of four images needs to be reloaded from the hard disk. RTMDet only needs to reload the current image, and the rest images participating in the mixed augmentation are obtained from the cache queue, which greatly improves the efficiency by sacrificing a certain memory space. Moreover, we can modify the cache size and pop mode to adjust the strength of augmentation. + +
+data cache +
+ +As shown in the figure, N loaded images and labels are stored in the cache queue in advance. In each training step, only a new image and its label need to be loaded and updated to the cache queue (the images in the cache queue can be repeated, as shown in the figure for img3 twice). Meanwhile, if the cache queue length exceeds the preset length, it will pop a random image (in order to make the Tiny model more stable, the Tiny model doesn't use the random pop, but removes the first added image). When mixed data augmentation is needed, only the required images need to be randomly selected from the cache for splicing and other processing, instead of loading them all from the hard disk, which saves the time of image loading. + +```{note} +The maximum length N of the cache queue is an adjustable parameter. According to the empirical principle, when ten caches are provided for each image to be blended, it can be considered to provide enough randomness, while the Mosaic enhancement is four image blends, so the number of caches defaults to N=40. Similarly, MixUp has a default cache size of 20, but tiny model requires more stable training conditions, so it has half cache size of other specs (10 for MixUp and 20 for Mosaic). +``` + +In the implementation, MMYOLO designed the `BaseMiximageTransform` class to support mixed data augmentation of multiple images: + +```python +if self.use_cached: + # Be careful: deep copying can be very time-consuming + # if results includes dataset. + dataset = results.pop('dataset', None) + self.results_cache.append(copy.deepcopy(results)) # Cache the currently loaded data + if len(self.results_cache) > self.max_cached_images: + if self.random_pop: # Except for the tiny model, self.random_pop=True + index = random.randint(0, len(self.results_cache) - 1) + else: + index = 0 + self.results_cache.pop(index) + + if len(self.results_cache) <= 4: + return results +else: + assert 'dataset' in results + # Be careful: deep copying can be very time-consuming + # if results includes dataset. + dataset = results.pop('dataset', None) +``` + +#### 1.1.2 Mosaic + +Mosaic concatenates four images into a large image, which is equivalent to increasing the batch size, as follows: + +1. Randomly resample three images from customize datasets based on the index, possibly repeated. + +```python +def get_indexes(self, dataset: Union[BaseDataset, list]) -> list: + """Call function to collect indexes. + + Args: + dataset (:obj:`Dataset` or list): The dataset or cached list. + + Returns: + list: indexes. + """ + indexes = [random.randint(0, len(dataset)) for _ in range(3)] + return indexes +``` + +2. Randomly select the midpoint of the intersection of four images. + +```python +# mosaic center x, y +center_x = int( + random.uniform(*self.center_ratio_range) * self.img_scale[1]) +center_y = int( + random.uniform(*self.center_ratio_range) * self.img_scale[0]) +center_position = (center_x, center_y) +``` + +3. Read and concatenate images based on the sampled index. Using the `keep-ratio` resize image (i.e. the maximum edge must be 640) before concatenating. + +```python +# keep_ratio resize +scale_ratio_i = min(self.img_scale[0] / h_i, + self.img_scale[1] / w_i) +img_i = mmcv.imresize( + img_i, (int(w_i * scale_ratio_i), int(h_i * scale_ratio_i))) +``` + +4. After concatenating images, the bboxes and labels are all concatenated together, and then the bboxes are cropped but not filtered (some invalid bboxes may appear). + +```python +mosaic_bboxes.clip_([2 * self.img_scale[0], 2 * self.img_scale[1]]) +``` + +Please reference the Mosaic theory of [YOLOv5](./yolov5_description.md) for more details. + +#### 1.1.3 MixUp + +The MixUp implementation of RTMDet is the same as YOLOX, with the addition of cache function similar to above mentioned. + +Please reference the MixUp theory of [YOLOv5](./yolov5_description.md) for more details. + +#### 1.1.4 Strong and weak two-stage training + +Mosaic + MixUp has high distortion. Continuously using strong data augmentation isn't beneficial. YOLOX use strong and weak two-stage training mode firstly. However, the introduction of rotation and shear result in box annotation errors, which needs to introduce L1 loss to correct the performance of regression branch. + +In order to make the data augmentation method more general, RTMDet uses Mosaic + MixUp without rotation during the first 280 epochs, and increases the intensity and positive samples by mixing eight images. During the last 20 epochs, a relatively small learning rate is used to fine-tune under weak agumentation, and slowly update parameters to model by EMA, which could obtain a large improvement. + +| | RTMDet-s | RTMDet-l | +| ----------------------------- | -------- | -------- | +| LSJ + rand crop | 42.3 | 46.7 | +| Mosaic+MixUp | 41.9 | 49.8 | +| Mosaic + MixUp + 20e finetune | 43.9 | **51.3** | + +### 1.2 Model structure diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/yolov5_description.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/yolov5_description.md new file mode 100644 index 0000000000000000000000000000000000000000..4d2ed512e5022e94da9e1b87593df3536c366a24 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/yolov5_description.md @@ -0,0 +1,651 @@ +# Algorithm principles and implementation with YOLOv5 + +## 0 Introduction + +
+YOLOv5-P5_structure_v3.4 +Figure 1: YOLOv5-l-P5 model structure +
+ +
+YOLOv5-P6_structure_v1.1 +Figure 2: YOLOv5-l-P6 model structure +
+ +RangeKing@github provides the graph above. Thanks, RangeKing! + +YOLOv5 is an open-source object detection algorithm for real-time industrial applications which has received extensive attention. The reason for the explosion of YOLOv5 is not simply due to its excellent performance. It is more about the overall utility and robustness of its library. +In short, the main features of YOLOv5 are: + +1. **Friendly and perfect deployment supports** +2. **Fast training speed**: the training time in the case of 300 epochs is similar to most of the one-stage and two-stage algorithms under 12 epochs, such as RetinaNet, ATSS, and Faster R-CNN. +3. **Abundant optimization for corner cases**: YOLOv5 has implemented many optimizations. The functions and documentation are richer as well. + +Figures 1 and 2 show that the main differences between the P5 and P6 versions of YOLOv5 are the network structure and the image input resolution. Other differences, such as the number of anchors and loss weights, can be found in the [configuration file](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py). This article will start with the principle of the YOLOv5 algorithm and then focus on analyzing the implementation in MMYOLO. The follow-up part includes the guide and speed benchmark of YOLOv5. + +```{hint} +Unless specified, the P5 model is described by default in this documentation. +``` + +We hope this article becomes your core document to start and master YOLOv5. Since YOLOv5 is still constantly updated, we will also keep updating this document. So please always catch up with the latest version. + +MMYOLO implementation configuration: https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/ + +YOLOv5 official repository: https://github.com/ultralytics/yolov5 + +## 1 v6.1 algorithm principle and MMYOLO implementation analysis + +YOLOv5 official release: https://github.com/ultralytics/yolov5/releases/tag/v6.1 + +
+YOLOv5 accuracy +
+ +
+YOLOv5 benchmark +
+ +The performance is shown in the table above. YOLOv5 has two models with different scales. P6 is larger with a 1280x1280 input size, whereas P5 is the model used more often. This article focuses on the structure of the P5 model. + +Usually, we divide the object detection algorithm into different parts, such as data augmentation, model structure, loss calculation, etc. It is the same as YOLOv5: + +
+Strategy +
+ +Now we will briefly analyze the principle and our specific implementation in MMYOLO. + +### 1.1 Data augmentation + +Many data augmentation methods are used in YOLOv5, including: + +- **Mosaic** +- **RandomAffine** +- **MixUp** +- **Image blur and other transformations using Albu** +- **HSV color space enhancement** +- **Random horizontal flips** + +The mosaic probability is set to `1`, so it will always be triggered. MixUp is not used for the small and nano models, and the probability is `0.1` for other l/m/x series models. As small models have limited capabilities, we generally do not use strong data augmentations like MixUp. + +The following picture demonstrates the `Mosaic + RandomAffine + MixUp` process. + +
+image +
+ +#### 1.1.1 Mosaic + +
+image +
+ +Mosaic is a hybrid data augmentation method requiring four images to be stitched together, which is equivalent to increasing the training batch size. + +We can summarize the process as: + +1. Randomly generates coordinates of the intersection point of the four spliced images. +2. Randomly select the indexes of the other three images and read the corresponding annotations. +3. Resizes each image to the specified size by maintaining its aspect ratio. +4. Calculate the position of each image in the output image according to the top, bottom, left, and right rule. You also need to calculate the crop coordinates because the image may be out of bounds. +5. Uses the crop coordinates to crop the scaled image and paste it to the position calculated. The rest of the places will be pad with `114 pixels`. +6. Process the label of each image accordingly. + +Note: since four images are stitched together, the output image area will be enlarged four times (from 640x640 to 1280x1280). Therefore, to revert to 640x640, you must add a **RandomAffine** transformation. Otherwise, the image area will always be four times larger. + +#### 1.1.2 RandomAffine + +
+image +
+ +RandomAffine has two purposes: + +1. Performs a stochastic geometric affine transformation to the image. +2. Reduces the size of the image generated by Mosaic back to 640x640. + +RandomAffine includes geometric augmentations such as translation, rotation, scaling, misalignment, etc. Since Mosaic and RandomAffine are strong augmentations, they will introduce considerable noise. Therefore, the enhanced annotations need to be processed. The rules are + +1. The width and height of the enhanced gt bbox should be larger than wh_thr; +2. The ratio of the area of gt bbox after and before the enhancement should be greater than ar_thr to prevent it from changing too much. +3. The maximum aspect ratio should be smaller than area_thr to prevent it from changing too much. + +Object detection algorithms will rarely use this augmentation method as the annotation box becomes larger after the rotation, resulting in inaccuracy. + +#### 1.1.3 MixUp + +
+image +
+ +MixUp, similar to Mosaic, is also a hybrid image augmentation. It randomly selects another image and mixes the two images together. There are various ways to do this, and the typical approach is to either stitch the label together directly or mix the label using `alpha` method. +The original author's approach is straightforward: the label is directly stitched, and the images are mixed by distributional sampling. + +Note: **In YOLOv5's implementation of MixUP, the other random image must be processed by Mosaic+RandomAffine before the mixing process.** This may not be the same as implementations in other open-source libraries. + +#### 1.1.4 Image blur and other augmentations + +
+image +
+ +The rest of the augmentations are: + +- **Image blur and other transformations using Albu** +- **HSV color space enhancement** +- **Random horizontal flips** + +The Albu library has been packaged in MMDetection so users can directly use all Albu's methods through simple configurations. As a very ordinary and common processing method, HSV will not be further introduced now. + +#### 1.1.5 The implementations in MMYOLO + +While conventional single-image augmentations such as random flip are relatively easy to implement, hybrid data augmentations like Mosaic are more complicated. Therefore, in MMDetection's reimplementation of YOLOX, a dataset wrapper called `MultiImageMixDataset` was introduced. The process is as follows: + +
+image +
+ +For hybrid data augmentations such as Mosaic, you need to implement an additional `get_indexes` method to retrieve the index information of other images and then perform the enhancement. +Take the YOLOX implementation in MMDetection as an example. The configuration file is like this: + +```python +train_pipeline = [ + dict(type='Mosaic', img_scale=img_scale, pad_val=114.0), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0), + ... +] + +train_dataset = dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type='CocoDataset', + pipeline=[ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True) + ]), + pipeline=train_pipeline) +``` + +MultiImageMixDataset passes in a data augmentation method, including Mosaic and RandomAffine. CocoDataset also adds a pipeline to load the images and the annotations. This way, it is possible to quickly achieve a hybrid data augmentation method. + +However, the above implementation has one drawback: **For users unfamiliar with MMDetection, they often forget that Mosaic must be used with MultiImageMixDataset. Otherwise, it will return an error. Plus, this approach increases the complexity and difficulty of understanding**. + +To solve this problem, we have simplified it further in MMYOLO. By making the dataset object directly accessible to the pipeline, the implementation and the use of hybrid data augmentations can be the same as random flipping. + +The configuration of YOLOX in MMYOLO is written as follows: + +```python +pre_transform = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True) +] + +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='mmdet.RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='YOLOXMixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0, + pre_transform=pre_transform), + ... +] +``` + +This eliminates the need for the MultiImageMixDataset and makes it much easier to use and understand. + +Back to the YOLOv5 configuration, since the other randomly selected image in the MixUp also needs to be enhanced by Mosaic+RandomAffine before it can be used, the YOLOv5-m data enhancement configuration is as follows. + +```python +pre_transform = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True) +] + +mosaic_transform= [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(0.1, 1.9), # scale = 0.9 + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +train_pipeline = [ + *pre_transform, + *mosaic_transform, + dict( + type='YOLOv5MixUp', + prob=0.1, + pre_transform=[ + *pre_transform, + *mosaic_transform + ]), + ... +] +``` + +### 1.2 Network structure + +This section was written by RangeKing@github. Thanks a lot! + +The YOLOv5 network structure is the standard `CSPDarknet` + `PAFPN` + `non-decoupled Head`. + +The size of the YOLOv5 network structure is determined by the `deepen_factor` and `widen_factor` parameters. `deepen_factor` controls the depth of the network structure, that is, the number of stacks of `DarknetBottleneck` modules in `CSPLayer`. `widen_factor` controls the width of the network structure, that is, the number of channels of the module output feature map. Take YOLOv5-l as an example. Its `deepen_factor = widen_factor = 1.0`. the overall structure is shown in the graph above. + +The upper part of the figure is an overview of the model; the lower part is the specific network structure, in which the modules are marked with numbers in serial, which is convenient for users to correspond to the configuration files of the YOLOv5 official repository. The middle part is the detailed composition of each sub-module. + +If you want to use **netron** to visualize the details of the network structure, open the ONNX file format exported by MMDeploy in netron. + +```{hint} +The shapes of the feature map in Section 1.2 are (B, C, H, W) by default. +``` + +#### 1.2.1 Backbone + +`CSPDarknet` in MMYOLO inherits from `BaseBackbone`. The overall structure is similar to `ResNet` with a total of 5 layers of design, including one `Stem Layer` and four `Stage Layer`: + +- `Stem Layer` is a `ConvModule` whose kernel size is 6x6. It is more efficient than the `Focus` module used before v6.1. +- Except for the last `Stage Layer`, each `Stage Layer` consists of one `ConvModule` and one `CSPLayer`, as shown in the Details part in the graph above. `ConvModule` is a 3x3 `Conv2d` + `BatchNorm` + `SiLU activation function` module. `CSPLayer` is the C3 module in the official YOLOv5 repository, consisting of three `ConvModule` + n `DarknetBottleneck` with residual connections. +- The last `Stage Layer` adds an `SPPF` module at the end. The `SPPF` module is to serialize the input through multiple 5x5 `MaxPool2d` layers, which has the same effect as the `SPP` module but is faster. +- The P5 model passes the corresponding results from the second to the fourth `Stage Layer` to the `Neck` structure and extracts three output feature maps. Take a 640x640 input image as an example. The output features are (B, 256, 80, 80), (B,512,40,40), and (B,1024,20,20). The corresponding stride is 8/16/32. +- The P6 model passes the corresponding results from the second to the fifth `Stage Layer` to the `Neck` structure and extracts three output feature maps. Take a 1280x1280 input image as an example. The output features are (B, 256, 160, 160), (B,512,80,80), (B,768,40,40), and (B,1024,20,20). The corresponding stride is 8/16/32/64. + +#### 1.2.2 Neck + +There is no **Neck** part in the official YOLOv5. However, to facilitate users to correspond to other object detection networks easier, we split the `Head` of the official repository into `PAFPN` and `Head`. + +Based on the `BaseYOLONeck` structure, YOLOv5's `Neck` also follows the same build process. However, for non-existed modules, we use `nn.Identity` instead. + +The feature maps output by the Neck module is the same as the Backbone. The P5 model is (B,256,80,80), (B,512,40,40) and (B,1024,20,20); the P6 model is (B,256,160,160), (B,512,80,80), (B,768,40,40) and (B,1024,20,20). + +#### 1.2.3 Head + +The `Head` structure of YOLOv5 is the same as YOLOv3, which is a `non-decoupled Head`. The Head module includes three convolution modules that do not share weights. They are used only for input feature map transformation. + +The `PAFPN` outputs three feature maps of different scales, whose shapes are (B,256,80,80), (B,512,40,40), and (B,1024,20,20) accordingly. + +Since YOLOv5 has a non-decoupled output, that is, classification and bbox detection results are all in different channels of the same convolution module. Taking the COCO dataset as an example: + +- When the input of P5 model is 640x640 resolution, the output shapes of the Head module are `(B, 3x(4+1+80),80,80)`, `(B, 3x(4+1+80),40,40)` and `(B, 3x(4+1+80),20,20)`. + +- When the input of P6 model is 1280x1280 resolution, the output shapes of the Head module are `(B, 3x(4+1+80),160,160)`, `(B, 3x(4+1+80),80,80)`, `(B, 3x(4+1+80),40,40)` and `(B, 3x(4+1+80),20,20)`. + + `3` represents three anchors, `4` represents the bbox prediction branch, `1` represents the obj prediction branch, and `80` represents the class prediction branch of the COCO dataset. + +### 1.3 Positive and negative sample assignment strategy + +The core of the positive and negative sample assignment strategy is to determine which positions in all positions of the predicted feature map should be positive or negative and even which samples will be ignored. + +This is one of the most significant components of the object detection algorithm because a good strategy can improve the algorithm's performance. + +The assignment strategy of YOLOv5 can be briefly summarized as calculating the shape-matching rate between anchor and gt_bbox. Plus, the cross-neighborhood grid is also introduced to get more positive samples. + +It consists of the following two main steps: + +1. For any output layer, instead of the commonly used strategy based on Max IoU matching, YOLOv5 switched to comparing the shape matching ratio. First, the GT Bbox and the anchor of the current layer are used to calculate the aspect ratio. If the ratio is greater than the threshold, the GT Bbox and Anchor are considered not matched. Then the current GT Bbox is temporarily discarded, and the predicted position in the grid of this GT Bbox in the current layer is regarded as a negative sample. +2. For the remaining GT Bboxes (the matched GT Bboxes), YOLOv5 calculates which grid they fall in. Using the rounding rule to find the nearest two grids and considering all three grids as a group that is responsible for predicting the GT Bbox. The number of positive samples has increased by at least three times compared to the previous YOLO series algorithms. + +Now we will explain each part of the assignment strategy in detail. Some descriptions and illustrations are directly or indirectly referenced from the official [repo](https://github.com/ultralytics/YOLOv5/issues/6998#44). + +#### 1.3.1 Anchor settings + +YOLOv5 is an anchor-based object detection algorithm. Similar to YOLOv3, the anchor sizes are still obtained by clustering. However, the difference compared with YOLOv3 is that instead of clustering based on IoU, YOLOv5 switched to using the aspect ratio on the width and height (shape-match based method). + +While training on customized data, user can use the tool in MMYOLO to analyze and get the appropriate anchor sizes of the dataset. + +```shell +python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm v5-k-means + --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR} +``` + +Then modify the default anchor size setting in the [config file](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py): + +```python +anchors = [[(10, 13), (16, 30), (33, 23)], [(30, 61), (62, 45), (59, 119)], + [(116, 90), (156, 198), (373, 326)]] +``` + +#### 1.3.2 Bbox encoding and decoding process + +The predicted bounding box will transform based on the pre-set anchors in anchor-based algorithms. Then, the transformation amount is predicted, known as the GT Bbox encoding process. Finally, the Pred Bbox decoding needs to be performed after the prediction to restore the bboxes to the original scale, known as the Pred Bbox decoding process. + +In YOLOv3, the bbox regression formula is: + +```{math} +b_x=\sigma(t_x)+c_x \\ +b_y=\sigma(t_y)+c_y \\ +b_w=a_w\cdot e^{t_w} \\ +b_h=a_h\cdot e^{t_h} \\ +``` + +In the above formula， + +```{math} +a_w represents the width of the anchor \\ +c_x represents the coordinate of the grid \\ +\sigma represents the Sigmoid function. +``` + +However, the regression formula in YOLOv5 is： + +```{math} +b_x=(2\cdot\sigma(t_x)-0.5)+c_x \\ +b_y=(2\cdot\sigma(t_y)-0.5)+c_y \\ +b_w=a_w\cdot(2\cdot\sigma(t_w))^2 \\ +b_h=a_h\cdot(2\cdot\sigma(t_h))^2 +``` + +Two main changes are: + +- adjusted the range of the center point coordinate from (0, 1) to (-0.5, 1.5); +- adjusted the width and height from + +```{math} +(0，+\infty) +``` + +to + +```{math} +(0，4a_{wh}) +``` + +The changes have the two benefits: + +- It will be **better to predict zero and one** with the changed center point range, which makes the bbox coordinate regression more accurate. + +
+image +
+ +- `exp(x)` in the width and height regression formula is unbounded, which may cause the **gradient out of control** and make the training stage unstable. The revised width-height regression in YOLOv5 optimizes this problem. + +
+image +
+ +#### 1.3.3 Assignment strategy + +Note: in MMYOLO, **we call anchor as prior** for both anchor-based and anchor-free networks. + +Positive sample assignment consists of the following two steps: + +(1) Scale comparison + +Compare the scale of the WH in the GT BBox and the WH in the Prior: + +```{math} +r_w = w\_{gt} / w\_{pt} \\ +r_h = h\_{gt} / h\_{pt} \\ +r_w^{max}=max(r_w, 1/r_w) \\ +r_h^{max}=max(r_h, 1/r_h) \\ +r^{max}=max(r_w^{max}, r_h^{max}) \\ +if\ \ r_{max} < prior\_match\_thr: match! +``` + +Taking the assignment process of the GT Bbox and the Prior of the P3 feature map as the example: + +
+image +
+ +The reason why Prior 1 fails to match the GT Bbox is because: + +```{math} +h\_{gt}\ /\ h\_{prior}\ =\ 4.8\ >\ prior\_match\_thr +``` + +(2) Assign corresponded positive samples to the matched GT BBox in step 1 + +We still use the example in the previous step. + +The value of (cx, cy, w, h) of the GT BBox is (26, 37, 36, 24), and the WH value of the Prior is \[(15, 5), (24, 16), (16, 24)\]. In the P3 feature map, the stride is eight. Prior 2 and prior 3 are matched. + +The detailed process can be described as: + +(2.1) Map the center point coordinates of the GT Bbox to the grid of P3. + +```{math} +GT_x^{center_grid}=26/8=3.25 \\ +GT_y^{center_grid}=37/8=4.625 +``` + +
+image +
+ +(2.2) Divide the grid where the center point of GT Bbox locates into four quadrants. **Since the center point falls in the lower left quadrant, the left and lower grids of the object will also be considered positive samples**. + +
+image +
+ +The following picture shows the distribution of positive samples when the center point falls to different positions: + +
+image +
+ +So what improvements does the Assign method bring to YOLOv5? + +- One GT Bbox can match multiple Priors. + +- When a GT Bbox matches a Prior, at most three positive samples can be assigned. + +- These strategies can **moderately alleviate the problem of unbalanced positive and negative samples, which is very common in object detection algorithms**. + +The regression method in YOLOv5 corresponds to the Assign method: + +1. Center point regression: + +
+image +
+ +2. WH regression: + +
+image +
+ +### 1.4 Loss design + +YOLOv5 contains a total of three Loss, which are: + +- Classes loss: BCE loss +- Objectness loss: BCE loss +- Location loss: CIoU loss + +These three losses are aggregated according to a certain proportion: + +```{math} +Loss=\lambda_1L_{cls}+\lambda_2L_{obj}+\lambda_3L_{loc} +``` + +The Objectness loss corresponding to the P3, P4, and P5 layers are added according to different weights. The default setting is + +```python +obj_level_weights=[4., 1., 0.4] +``` + +```{math} +L_{obj}=4.0\cdot L_{obj}^{small}+1.0\cdot L_{obj}^{medium}+0.4\cdot L_{obj}^{large} +``` + +In the reimplementation, we found a certain gap between the CIoU used in YOLOv5 and the latest official CIoU, which is reflected in the calculation of the alpha parameter. + +In the official version: + +Reference: https://github.com/Zzh-tju/CIoU/blob/master/layers/modules/multibox_loss.py#L53-L55 + +```python +alpha = (ious > 0.5).float() * v / (1 - ious + v) +``` + +In YOLOv5's version: + +```python +alpha = v / (v - ious + (1 + eps)) +``` + +This is an interesting detail, and we need to test the accuracy gap caused by different alpha calculation methods in our follow-up development. + +### 1.5 Optimization and training strategies + +YOLOv5 has very fine-grained control over the parameter groups of each optimizer, which briefly includes the following sections. + +#### 1.5.1 Optimizer grouping + +The optimization parameters are divided into three groups: Conv/Bias/BN. In the WarmUp stage, different groups use different lr and momentum update curves. +At the same time, the iter-based update strategy is adopted in the WarmUp stage, and it becomes an epoch-based update strategy in the non-WarmUp stage, which is quite tricky. + +In MMYOLO, the YOLOv5OptimizerConstructor optimizer constructor is used to implement optimizer parameter grouping. The role of an optimizer constructor is to control the initialization process of some special parameter groups finely so that it can meet the needs well. + +Different parameter groups use different scheduling curve functions through YOLOv5ParamSchedulerHook. + +#### 1.5.2 weight decay parameter auto-adaptation + +The author adopts different weight decay strategies for different batch sizes, specifically: + +1. When the training batch size does not exceed 64, weight decay remains unchanged. +2. When the training batch size exceeds 64, weight decay will be linearly scaled according to the total batch size. + +MMYOLO also implements through the YOLOv5OptimizerConstructor. + +#### 1.5.3 Gradient accumulation + +To maximize the performance under different batch sizes, the author sets the gradient accumulation function automatically when the total batch size is less than 64. + +The training process is similar to most YOLO, including the following strategies: + +1. Not using pre-trained weights. +2. There is no multi-scale training strategy, and cudnn.benchmark can be turned on to accelerate training further. +3. The EMA strategy is used to smooth the model. +4. Automatic mixed-precision training with AMP by default. + +What needs to be reminded is that the official YOLOv5 repository uses single-card v100 training for the small model with a bs is 128. However, m/l/x models are trained with different numbers of multi-cards. +This training strategy is not relatively standard, **For this reason, eight cards are used in MMYOLO, and each card sets the bs to 16. At the same time, in order to avoid performance differences, SyncBN is turned on during training**. + +### 1.6 Inference and post-processing + +The YOLOv5 post-processing is very similar to YOLOv3. In fact, all post-processing stages of the YOLO series are similar. + +#### 1.6.1 Core parameters + +1. **multi_label** + +For multi-category prediction, you need to consider whether it is a multi-label case or not. Multi-label case predicts probabilities of more than one category at one location. As YOLOv5 uses sigmoid, it is possible that one object may have two different predictions. It is good to evaluate mAP, but not good to use. +Therefore, multi_label is set to `True` during the evaluation and changed to `False` for inferencing and practical usage. + +2. **score_thr and nms_thr** + +The score_thr threshold is used for the score of each category, and the detection boxes with a score below the threshold are treated as background. nms_thr is used for nms process. During the evaluation, score_thr can be set very low, which improves the recall and the mAP. However, it is meaningless for practical usage and leads to a very slow inference performance. For this reason, different thresholds are set in the testing and inference phases. + +3. **nms_pre and max_per_img** + +nms_pre is the maximum number of frames to be preserved before NMS, which is used to prevent slowdown caused by too many input frames during the NMS process. max_per_img is the final maximum number of frames to be reserved, usually set to 300. + +Take the COCO dataset as an example. It has 80 classes, and the input size is 640x640. + +
+image +
+ +The inference and post-processing include: + +**(1) Dimensional transformation** + +YOLOv5 outputs three feature maps. Each feature map is scaled at 80x80, 40x40, and 20x20. As three anchors are at each position, the output feature map channel is 3x(5+80)=255. +YOLOv5 uses a non-decoupled Head, while most other algorithms use decoupled Head. Therefore, to unify the post-processing logic, we decouple YOLOv5's Head into the category prediction branch, the bbox prediction branch, and the obj prediction branch. + +The three scales of category prediction, bbox prediction, and obj prediction are stitched together and dimensionally transformed. For subsequent processing, the original channel dimensions are replaced at the end, and the shapes of the category prediction branch, bbox prediction branch, and obj prediction branch are (b, 3x80x80+3x40x40+3x20x20, 80)=(b,25200,80), (b,25200,4), and (b,25200,1), respectively. + +**(2) Decoding to the original graph scale** + +The classification branch and obj branch need to be computed with the sigmoid function, while the bbox prediction branch needs to be decoded and reduced to the original image in xyxy format. + +**(3) First filtering** + +Iterate through each graph in the batch, and then use score_thr to threshold filter the category prediction scores to remove the prediction results below score_thr. + +**(4) Second filtering** + +Multiply the obj prediction scores and the filtered category prediction scores, and then still use score_thr for threshold filtering. +It is also necessary to consider **multi_label and nms_pre in this process to ensure that the number of detected boxes after filtering is no more than nms_pre**. + +**(5) Rescale to original size and NMS** + +Based on the pre-processing process, restore the remaining detection frames to the original graph scale before the network output and perform NMS. The final output detection frame cannot be more than **max_per_img**. + +#### 1.6.2 batch shape strategy + +To speed up the inference process on the validation set, the authors propose the batch shape strategy, whose principle is to **ensure that the images within the same batch have the least number of pad pixels in the batch inference process and do not require all the images in the batch to have the same scale throughout the validation process**. + +It first sorts images according to their aspect ratio of the entire test or validation set, and then forms a batch of the sorted images based on the settings. +At the same time, the batch shape of the current batch is calculated to prevent too many pad pixels. We focus on padding with the original aspect ratio but not padding the image to a perfect square. + +```python + image_shapes = [] + for data_info in data_list: + image_shapes.append((data_info['width'], data_info['height'])) + + image_shapes = np.array(image_shapes, dtype=np.float64) + + n = len(image_shapes) # number of images + batch_index = np.floor(np.arange(n) / self.batch_size).astype( + np.int64) # batch index + number_of_batches = batch_index[-1] + 1 # number of batches + + aspect_ratio = image_shapes[:, 1] / image_shapes[:, 0] # aspect ratio + irect = aspect_ratio.argsort() + + data_list = [data_list[i] for i in irect] + + aspect_ratio = aspect_ratio[irect] + # Set training image shapes + shapes = [[1, 1]] * number_of_batches + for i in range(number_of_batches): + aspect_ratio_index = aspect_ratio[batch_index == i] + min_index, max_index = aspect_ratio_index.min( + ), aspect_ratio_index.max() + if max_index < 1: + shapes[i] = [max_index, 1] + elif min_index > 1: + shapes[i] = [1, 1 / min_index] + + batch_shapes = np.ceil( + np.array(shapes) * self.img_size / self.size_divisor + + self.pad).astype(np.int64) * self.size_divisor + + for i, data_info in enumerate(data_list): + data_info['batch_shape'] = batch_shapes[batch_index[i]] +``` + +## 2 Sum up + +This article focuses on the principle of YOLOv5 and our implementation in MMYOLO in detail, hoping to help users understand the algorithm and the implementation process. At the same time, again, please note that since YOLOv5 itself is constantly being updated, this open-source library will also be continuously iterated. So please always check the latest version. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/yolov8_description.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/yolov8_description.md new file mode 100644 index 0000000000000000000000000000000000000000..70f1686b4f461bc07fe101dd8e011deb220d3767 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/algorithm_descriptions/yolov8_description.md @@ -0,0 +1,241 @@ +# Algorithm principles and implementation with YOLOv8 + +## 0 Introduction + +
+YOLOv8-P5_structure +Figure 1：YOLOv8-P5 +
+ +RangeKing@github provides the graph above. Thanks, RangeKing! + +YOLOv8 is the next major update from YOLOv5, open sourced by Ultralytics on 2023.1.10, and now supports image classification, object detection and instance segmentation tasks. + +
+YOLOv8-logo +Figure 2：YOLOv8-logo +
+According to the official description, Ultralytics YOLOv8 is the latest version of the YOLO object detection and image segmentation model developed by Ultralytics. YOLOv8 is a cutting-edge, state-of-the-art (SOTA) model that builds upon the success of previous YOLO versions and introduces new features and improvements to further boost performance and flexibility. These include a new backbone network, a new anchor-free detection head, and a new loss function. YOLOv8 is also highly efficient and can be run on a variety of hardware platforms, from CPUs to GPUs. + +However, instead of naming the open source library YOLOv8, ultralytics uses the word ultralytics directly because ultralytics positions the library as an algorithmic framework rather than a specific algorithm, with a major focus on scalability. It is expected that the library can be used not only for the YOLO model family, but also for non-YOLO models and various tasks such as classification segmentation pose estimation. + +Overall, YOLOv8 is a powerful and flexible tool for object detection and image segmentation that offers the best of both worlds: **the SOTA technology and the ability to use and compare all previous YOLO versions.** + +
+YOLOv8-table +Figure 3：YOLOv8-performance +
+ +YOLOv8 official open source address: [this](https://github.com/ultralytics/ultralytics) + +MMYOLO open source address for YOLOv8: [this](https://github.com/open-mmlab/mmyolo/blob/dev/configs/yolov8/) + +The following table shows the official results of mAP, number of parameters and FLOPs tested on the COCO Val 2017 dataset. It is evident that YOLOv8 has significantly improved precision compared to YOLOv5. However, the number of parameters and FLOPs of the N/S/M models have significantly increased. Additionally, it can be observed that the inference speed of YOLOv8 is slower in comparison to most of the YOLOv5 models. + +| **model** | **YOLOv5** | **params(M)** | **FLOPs@640 (B)** | **YOLOv8** | **params(M)** | **FLOPs@640 (B)** | +| --------- | ----------- | ------------- | ----------------- | ----------- | ------------- | ----------------- | +| n | 28.0(300e) | 1.9 | 4.5 | 37.3 (500e) | 3.2 | 8.7 | +| s | 37.4 (300e) | 7.2 | 16.5 | 44.9 (500e) | 11.2 | 28.6 | +| m | 45.4 (300e) | 21.2 | 49.0 | 50.2 (500e) | 25.9 | 78.9 | +| l | 49.0 (300e) | 46.5 | 109.1 | 52.9 (500e) | 43.7 | 165.2 | +| x | 50.7 (300e) | 86.7 | 205.7 | 53.9 (500e) | 68.2 | 257.8 | + +It is worth mentioning that the recent YOLO series have shown significant performance improvements on the COCO dataset. However, their generalizability on custom datasets has not been extensively tested, which thereby will be a focus in the future development of MMYOLO. + +Before reading this article, if you are not familiar with YOLOv5, YOLOv6 and RTMDet, you can read the detailed explanation of [YOLOv5 and its implementation](https://mmyolo.readthedocs.io/en/latest/algorithm_descriptions/yolov5_description.html). + +## 1 YOLOv8 Overview + +The core features and modifications of YOLOv8 can be summarized as follows: + +1. **A new state-of-the-art (SOTA) model is proposed, featuring an object detection model for P5 640 and P6 1280 resolutions, as well as a YOLACT-based instance segmentation model. The model also includes different size options with N/S/M/L/X scales, similar to YOLOv5, to cater to various scenarios.** +2. **The backbone network and neck module are based on the YOLOv7 ELAN design concept, replacing the C3 module of YOLOv5 with the C2f module. However, there are a lot of operations such as Split and Concat in this C2f module that are not as deployment-friendly as before.** +3. **The Head module has been updated to the current mainstream decoupled structure, separating the classification and detection heads, and switching from Anchor-Based to Anchor-Free.** +4. **The loss calculation adopts the TaskAlignedAssigner in TOOD and introduces the Distribution Focal Loss to the regression loss.** +5. **In the data augmentation part, Mosaic is closed in the last 10 training epoch, which is the same as YOLOX training part.** + **As can be seen from the above summaries, YOLOv8 mainly refers to the design of recently proposed algorithms such as YOLOX, YOLOv6, YOLOv7 and PPYOLOE.** + +Next, we will introduce various improvements in the YOLOv8 model in detail by 5 parts: model structure design, loss calculation, training strategy, model inference process and data augmentation. + +## 2 Model structure design + +The Figure 1 is the model structure diagram based on the official code of YOLOv8. **If you like this style of model structure diagram, welcome to check out the model structure diagram in algorithm README of MMYOLO, which currently covers YOLOv5, YOLOv6, YOLOX, RTMDet and YOLOv8.** + +Comparing the YOLOv5 and YOLOv8 yaml configuration files without considering the head module, you can see that the changes are minor. + +
+yaml +Figure 4：YOLOv5 and YOLOv8 YAML diff +
+ +The structure on the left is YOLOv5-s and the other side is YOLOv8-s. The specific changes in the backbone network and neck module are: + +- The kernel of the first convolutional layer has been changed from 6x6 to 3x3 +- All C3 modules are replaced by C2f, and the structure is as follows, with more skip connections and additional split operations. + +
+module +Figure 5：YOLOv5 and YOLOv8 module diff +
+ +- Removed 2 convolutional connection layers from neck module +- The block number has been changed from 3-6-9-3 to 3-6-6-3. +- **If we look at the N/S/M/L/X models, we can see that of the N/S and L/X models only changed the scaling factors, but the number of channels in the S/ML backbone network is not the same and does not follow the same scaling factor principle. The main reason for this design is that the channel settings under the same set of scaling factors are not the most optimal, and the YOLOv7 network design does not follow one set of scaling factors for all models either.** + +The most significant changes in the model lay in the head module. The head module has been changed from the original coupling structure to the decoupling one, and its style has been changed from **YOLOv5's Anchor-Based to Anchor-Free**. The structure is shown below. + +
+head +Figure 6：YOLOv8 Head +
+ +As demonstrated, the removal of the objectness branch and the retention of only the decoupled classification and regression branches stand as the major differences. Additionally, the regression branch now employs integral form representation as proposed in the Distribution Focal Loss. + +## 3 Loss calculation + +The loss calculation process consists of 2 parts: the sample assignment strategy and loss calculation. + +The majority of contemporary detectors employ dynamic sample assignment strategies, such as YOLOX's simOTA, TOOD's TaskAlignedAssigner, and RTMDet's DynamicSoftLabelAssigner. Given the superiority of dynamic assignment strategies, the YOLOv8 algorithm directly incorporates the one employed in TOOD's TaskAlignedAssigner. + +The matching strategy of TaskAlignedAssigner can be summarized as follows: positive samples are selected based on the weighted scores of classification and regression. + +```{math} +t=s^\alpha+u^\beta +``` + +`s` is the prediction score corresponding to the ground truth category, `u` is the IoU of the prediction bounding box and the gt bounding box. + +1. For each ground truth, the task-aligned assigner calculates the `alignment metric` for each anchor by taking the weighted product of two values: the predicted classification score of the corresponding class, and the Intersection over Union (IoU) between the predicted bounding box and the Ground Truth bounding box. +2. For each Ground Truth, the larger top-k samples are selected as positive based on the `alignment_metrics` values directly. + +The loss calculation consists of 2 parts: the classification and regression, without the objectness loss in the previous model. + +- The classification branch still uses BCE Loss. +- The regression branch employs both Distribution Focal Loss and CIoU Loss. + +The 3 Losses are weighted by a specific weight ratio. + +## 4 Data augmentation + +YOLOv8's data augmentation is similar to YOLOv5, whereas it stops the Mosaic augmentation in the final 10 epochs as proposed in YOLOX. The data process pipelines are illustrated in the diagram below. + +
+head +Figure 7：pipeline +
+ +The intensity of data augmentation required for different scale models varies, therefore the hyperparameters for the scaled models are adjusted depending on the situation. For larger models, techniques such as MixUp and CopyPaste are typically employed. The result of data augmentation can be seen in the example below: + +
+head +Figure 8：results +
+ +The above visualization result can be obtained by running the [browse_dataset](https://github.com/open-mmlab/mmyolo/blob/dev/tools/analysis_tools/browse_dataset.py) script. + +As the data augmentation process utilized in YOLOv8 is similar to YOLOv5, we will not delve into the specifics within this article. For a more in-depth understanding of each data transformation, we recommend reviewing the [YOLOv5 algorithm analysis document](https://mmyolo.readthedocs.io/en/latest/algorithm_descriptions/yolov5_description.html#id2) in MMYOLO. + +## 5 Training strategy + +The distinctions between the training strategy of YOLOv8 and YOLOv5 are minimal. The most notable variation is that the overall number of training epochs for YOLOv8 has been raised from 300 to 500, resulting in a significant expansion in the duration of training. As an illustration, the training strategy for YOLOv8-S can be succinctly outlined as follows: + +| config | YOLOv8-s P5 hyp | +| ---------------------- | ------------------------------- | +| optimizer | SGD | +| base learning rate | 0.01 | +| Base weight decay | 0.0005 | +| optimizer momentum | 0.937 | +| batch size | 128 | +| learning rate schedule | linear | +| training epochs | **500** | +| warmup iterations | max(1000，3 * iters_per_epochs) | +| input size | 640x640 | +| EMA decay | 0.9999 | + +## 6 Inference process + +The inference process of YOLOv8 is almost the same as YOLOv5. The only difference is that the integral representation bbox in Distribution Focal Loss needs to be decoded into a regular 4-dimensional bbox, and the subsequent calculation process is the same as YOLOv5. + +Taking COCO 80 class as an example, assuming that the input image size is 640x640, the inference process implemented in MMYOLO is shown as follows. + +
+head +Figure 9：results +
+The inference and post-processing process is: + +**(1) Decoding bounding box** +Integrate the probability of the distance between the center and the boundary of the box into the mathematical expectation of the distances. + +**(2) Dimensional transformation** +YOLOv8 outputs three feature maps with `80x80`, `40x40` and `20x20` scales. A total of 6 classification and regression different scales of feature map are output by the head module. +The 3 different scales of category prediction branch and bbox prediction branch are combined and dimensionally transformed. For the convenience of subsequent processing, the original channel dimensions are transposed to the end, and the category prediction branch and bbox prediction branch shapes are (b, 80x80+40x40+20x20, 80)=(b,8400,80), (b,8400,4), respectively. + +**(3) Scale Restroation** +The classification prediction branch utilizes sigmoid calculations, whereas the bbox prediction branch requires decoding to xyxy format and conversion to the original scale of the input images. + +**(4) Thresholding** +Iterate through each graph in the batch and use `score_thr` to perform thresholding. In this process, we also need to consider multi_label and nms_pre to ensure that the number of detected bboxs after filtering is no more than nms_pre. + +**(5) Reduction to the original image scale and NMS** +Reusing the parameters for preprocessing, the remaining bboxs are first resized to the original image scale and then NMS is performed. The final number of bboxes cannot be more than `max_per_img`. + +Special Note: **The Batch shape inference strategy, which is present in YOLOv5, is currently not activated in YOLOv8. By performing a quick test in MMYOLO, it can be observed that activating the Batch shape strategy can result in an approximate AP increase of around 0.1% to 0.2%.** + +## 7 Feature map visualization + +A comprehensive set of feature map visualization tools are provided in MMYOLO to help users visualize the feature maps. + +Take the YOLOv8-s model as an example. The first step is to download the official weights, and then convert them to MMYOLO by using the [yolov8_to_mmyolo](https://github.com/open-mmlab/mmyolo/blob/dev/tools/model_converters/yolov8_to_mmyolo.py) script. Note that the script must be placed under the official repository in order to run correctly. + +Assuming that you want to visualize the effect of the 3 feature maps output by backbone and the weights are named 'mmyolov8s.pth'. Run the following command: + +```bash +cd mmyolo +python demo/featmap_vis_demo.py demo/demo.jpg configs/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco.py mmyolov8s.pth --channel-reductio squeeze_mean +``` + +In particular, to ensure that the feature map and image are shown aligned, the original `test_pipeline` configuration needs to be replaced with the following: + +```Python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # change + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +``` + +
+head +Figure 10：featmap +
+From the above figure, we can see that the different output feature maps are mainly responsible for predicting objects at different scales. +We can also visualize the 3 output feature maps of the neck layer. + +```bash +cd mmyolo +python demo/featmap_vis_demo.py demo/demo.jpg configs/yolov8/yolov8_s_syncbn_fast_8xb16-500e_coco.py mmyolov8s.pth --channel-reductio squeeze_mean --target-layers neck +``` + +
+head +Figure 11：featmap +
+ +From the above figure, we can find the features at the object are more focused. + +## Summary + +This article delves into the intricacies of the YOLOv8 algorithm, offering a comprehensive examination of its overall design, model structure, loss function, training data enhancement techniques, and inference process. To aid in comprehension, a plethora of diagrams are provided. + +In summary, YOLOv8 is a highly efficient algorithm that incorporates image classification, Anchor-Free object detection, and instance segmentation. Its detection component incorporates numerous state-of-the-art YOLO algorithms to achieve new levels of performance. + +MMYOLO open source address for YOLOV8 [this](https://github.com/open-mmlab/mmyolo/blob/dev/configs/yolov8/) + +MMYOLO Algorithm Analysis Tutorial address is [yolov5_description](https://mmyolo.readthedocs.io/en/latest/algorithm_descriptions/yolov5_description.html) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/application_examples/index.rst b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/application_examples/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..03c091d19f7376b804d505ec9187cdbc5602adfc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/application_examples/index.rst @@ -0,0 +1,7 @@ +MMYOLO application examples +******************** + +.. toctree:: + :maxdepth: 1 + + ionogram_detection.md diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/application_examples/ionogram_detection.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/application_examples/ionogram_detection.md new file mode 100644 index 0000000000000000000000000000000000000000..a1bc7cc919ac6dd52e1e781f3eda2d4773eb7207 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/application_examples/ionogram_detection.md @@ -0,0 +1,307 @@ +# A benchmark for ionogram real-time object detection based on MMYOLO + +## Dataset + +Digital ionogram is the most important way to obtain real-time ionospheric information. +Ionospheric structure detection is of great research significance for accurate extraction of ionospheric key parameters. + +This study utilize 4311 ionograms with different seasons obtained by the Chinese Academy of Sciences in Hainan, Wuhan, and Huailai to establish a dataset. The six structures, including Layer E, Es-l, Es-c, F1, F2, and Spread F are manually annotated using [labelme](https://github.com/wkentaro/labelme). [Dataset Download](https://github.com/VoyagerXvoyagerx/Ionogram_detection/releases/download/Dataset/Iono4311.zip) + +
+ + +Preview of annotated images + +
+ +1. Dataset prepration + +After downloading the data, put it in the root directory of the MMYOLO repository, and use `unzip test.zip` (for Linux) to unzip it to the current folder. The structure of the unzipped folder is as follows: + +```shell +Iono4311/ +├── images +| ├── 20130401005200.png +| └── ... +└── labels + ├── 20130401005200.json + └── ... +``` + +The `images` directory contains input images，while the `labels` directory contains annotation files generated by labelme. + +2. Convert the dataset into COCO format + +Use the script `tools/dataset_converters/labelme2coco.py` to convert labelme labels to COCO labels. + +```shell +python tools/dataset_converters/labelme2coco.py --img-dir ./Iono4311/images \ + --labels-dir ./Iono4311/labels \ + --out ./Iono4311/annotations/annotations_all.json +``` + +3. Check the converted COCO labels + +To confirm that the conversion process went successfully, use the following command to display the COCO labels on the images. + +```shell +python tools/analysis_tools/browse_coco_json.py --img-dir ./Iono4311/images \ + --ann-file ./Iono4311/annotations/annotations_all.json +``` + +4. Divide dataset into training set, validation set and test set + +Set 70% of the images in the dataset as the training set, 15% as the validation set, and 15% as the test set. + +```shell +python tools/misc/coco_split.py --json ./Iono4311/annotations/annotations_all.json \ + --out-dir ./Iono4311/annotations \ + --ratios 0.7 0.15 0.15 \ + --shuffle \ + --seed 14 +``` + +The file tree after division is as follows: + +```shell +Iono4311/ +├── annotations +│ ├── annotations_all.json +│ ├── class_with_id.txt +│ ├── test.json +│ ├── train.json +│ └── val.json +├── classes_with_id.txt +├── images +├── labels +├── test_images +├── train_images +└── val_images +``` + +## Config files + +The configuration files are stored in the directory `/projects/misc/ionogram_detection/`. + +1. Dataset analysis + +To perform a dataset analysis, a sample of 200 images from the dataset can be analyzed using the `tools/analysis_tools/dataset_analysis.py` script. + +```shell +python tools/analysis_tools/dataset_analysis.py projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py \ + --out-dir output +``` + +Part of the output is as follows: + +```shell +The information obtained is as follows: ++------------------------------+ +| Information of dataset class | ++---------------+--------------+ +| Class name | Bbox num | ++---------------+--------------+ +| E | 98 | +| Es-l | 27 | +| Es-c | 46 | +| F1 | 100 | +| F2 | 194 | +| Spread-F | 6 | ++---------------+--------------+ +``` + +This indicates that the distribution of categories in the dataset is unbalanced. + +
+ + +Statistics of object sizes for each category + +
+ +According to the statistics, small objects are predominant in the E, Es-l, Es-c, and F1 categories, while medium-sized objects are more common in the F2 and Spread F categories. + +2. Visualization of the data processing part in the config + +Taking YOLOv5-s as an example, according to the `train_pipeline` in the config file, the data augmentation strategies used during training include： + +- Mosaic augmentation +- Random affine +- Albumentations (include various digital image processing methods) +- HSV augmentation +- Random affine + +Use the **'pipeline'** mode of the script `tools/analysis_tools/browse_dataset.py` to obtains all intermediate images in the data pipeline. + +```shell +python tools/analysis_tools/browse_dataset.py projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py \ + -m pipeline \ + --out-dir output +``` + +
+ + +Visualization for intermediate images in the data pipeline + +
+ +3. Optimize anchor size + +Use the script `tools/analysis_tools/optimize_anchors.py` to obtain prior anchor box sizes suitable for the dataset. + +```shell +python tools/analysis_tools/optimize_anchors.py projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py \ + --algorithm v5-k-means \ + --input-shape 640 640 \ + --prior-match-thr 4.0 \ + --out-dir work_dirs/dataset_analysis_5_s +``` + +4. Model complexity analysis + +With the config file, the parameters and FLOPs can be calculated by the script `tools/analysis_tools/get_flops.py`. Take yolov5-s as an example: + +```shell +python tools/analysis_tools/get_flops.py projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py +``` + +The following output indicates that the model has 7.947G FLOPs with the input shape (640, 640), and a total of 7.036M learnable parameters. + +```shell +============================== +Input shape: torch.Size([640, 640]) +Model Flops: 7.947G +Model Parameters: 7.036M +============================== +``` + +## Train and test + +1. Train + +**Training visualization**: By following the tutorial of [Annotation-to-deployment workflow for custom dataset](https://mmyolo.readthedocs.io/en/dev/recommended_topics/labeling_to_deployment_tutorials.html#id11), this example uses [wandb](https://wandb.ai/site) to visulize training. + +**Debug tricks**: During the process of debugging code, sometimes it is necessary to train for several epochs, such as debugging the validation process or checking whether the checkpoint saving meets expectations. For datasets inherited from `BaseDataset` (such as `YOLOv5CocoDataset` in this example), setting `indices` in the `dataset` field can specify the number of samples per epoch to reduce the iteration time. + +```python +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=1, + dataset=dict( + type=_base_.dataset_type, + indices=200, # set indices=200，represent every epoch only iterator 200 samples + data_root=data_root, + metainfo=metainfo, + ann_file=train_ann_file, + data_prefix=dict(img=train_data_prefix), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.train_pipeline))) +``` + +**Start training**： + +```shell +python tools/train.py projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py +``` + +2. Test + +Specify the path of the config file and the model to start the test: + +```shell +python tools/test.py projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py \ + work_dirs/yolov5_s-v61_fast_1xb96-100e_ionogram/xxx +``` + +## Experiments and results + +### Choose a suitable batch size + +- Often, the batch size governs the training speed, and the ideal batch size will be the largest batch size supported by the available hardware. +- If the video memory is not yet fully utilized, doubling the batch size should result in a corresponding doubling (or close to doubling) of the training throughput. This is equivalent to maintaining a constant (or nearly constant) time per step as the batch size increases. +- Automatic Mixed Precision (AMP) is a technique to accelerate the training with minimal loss in accuracy. To enable AMP training, add `--amp` to the end of the training command. + +Hardware information: + +- GPU：V100 with 32GB memory +- CPU：10-core CPU with 40GB memory + +Results： + +| Model | Epoch(best) | AMP | Batchsize | Num workers | Memory Allocated | Training Time | Val mAP | +| -------- | ----------- | ----- | --------- | ----------- | ---------------- | ------------- | ------- | +| YOLOv5-s | 100(82) | False | 32 | 6 | 35.07% | 54 min | 0.575 | +| YOLOv5-s | 100(96) | True | 32 | 6 | 24.93% | 49 min | 0.578 | +| YOLOv5-s | 100(100) | False | 96 | 6 | 96.64% | 48 min | 0.571 | +| YOLOv5-s | 100(100) | True | 96 | 6 | 54.66% | **37** min | 0.575 | +| YOLOv5-s | 100(90) | True | 144 | 6 | 77.06% | 39 min | 0.573 | +| YOLOv5-s | 200(148) | True | 96 | 6 | 54.66% | 72 min | 0.575 | +| YOLOv5-s | 200(188) | True | 96 | **8** | 54.66% | 67 min | 0.576 | + +
+ + +The proportion of data loading time to the total time of each step. + +
+ +Based on the results above, we can conclude that + +- AMP has little impact on the accuracy of the model, but can significantly reduce memory usage while training. +- Increasing batch size by three times does not reduce the training time by a corresponding factor of three. According to the `data_time` recorded during training, the larger the batch size, the larger the `data_time`, indicating that data loading has become the bottleneck limiting the training speed. Increasing `num_workers`, the number of processes used to load data, can accelerate the training speed. + +### Ablation studies + +In order to obtain a training pipeline applicable to the dataset, the following ablation studies with the YOLOv5-s model as an example are performed. + +#### Data augmentation + +| Aug Method | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram_aug0.py) | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb32-100e_ionogram_mosaic.py) | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram_mosaic_affine.py) | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram_mosaic_affine_albu_hsv.py) | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py) | +| ---------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- | +| Mosaic | | √ | √ | √ | √ | +| Affine | | | √ | √ | √ | +| Albu | | | | √ | √ | +| HSV | | | | √ | √ | +| Flip | | | | | √ | +| Val mAP | 0.507 | 0.550 | 0.572 | 0.567 | 0.575 | + +The results indicate that mosaic augmentation and random affine transformation can significantly improve the performance on the validation set. + +#### Using pre-trained models + +If you prefer not to use pre-trained weights, you can simply set `load_from = None` in the config file. For experiments that do not use pre-trained weights, it is recommended to increase the base learning rate by a factor of four and extend the number of training epochs to 200 to ensure adequate model training. + +| Model | Epoch(best) | FLOPs(G) | Params(M) | Pretrain | Val mAP | Config | +| -------- | ----------- | -------- | --------- | -------- | ------- | ------------------------------------------------------------------------------------------------ | +| YOLOv5-s | 100(82) | 7.95 | 7.04 | Coco | 0.575 | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py) | +| YOLOv5-s | 200(145) | 7.95 | 7.04 | None | 0.565 | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-200e_ionogram_pre0.py) | +| YOLOv6-s | 100(54) | 24.2 | 18.84 | Coco | 0.584 | [config](/projects/misc/ionogram_detection/yolov6/yolov6_s_fast_1xb32-100e_ionogram.py) | +| YOLOv6-s | 200(188) | 24.2 | 18.84 | None | 0.557 | [config](/projects/misc/ionogram_detection/yolov6/yolov6_s_fast_1xb32-200e_ionogram_pre0.py) | + +
+ + +Comparison of loss reduction during training + +
+ +The loss reduction curve shows that when using pre-trained weights, the loss decreases faster. It can be seen that even using models pre-trained on natural image datasets can accelerate model convergence when fine-tuned on radar image datasets. + +### Benchmark for ionogram object detection + +| Model | epoch(best) | FLOPs(G) | Params(M) | pretrain | val mAP | test mAP | Config | Log | +| ----------- | ----------- | -------- | --------- | -------- | ------- | -------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | +| YOLOv5-s | 100(82) | 7.95 | 7.04 | Coco | 0.575 | 0.584 | [config](/projects/misc/ionogram_detection/yolov5/yolov5_s-v61_fast_1xb96-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov5_s_20230105_213510.json) | +| YOLOv5-m | 100(70) | 24.05 | 20.89 | Coco | 0.587 | 0.586 | [config](/projects/misc/ionogram_detection/yolov5/yolov5_m-v61_fast_1xb32-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov5_m_20230106_004642.json) | +| YOLOv6-s | 100(54) | 24.2 | 18.84 | Coco | 0.584 | 0.594 | [config](/projects/misc/ionogram_detection/yolov6/yolov6_s_fast_1xb32-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov6_s_20230107_003207.json) | +| YOLOv6-m | 100(76) | 37.08 | 44.42 | Coco | 0.590 | 0.590 | [config](/projects/misc/ionogram_detection/yolov6/yolov6_m_fast_1xb32-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov6_m_20230107_201029.json) | +| YOLOv6-l | 100(76) | 71.33 | 58.47 | Coco | 0.605 | 0.597 | [config](/projects/misc/ionogram_detection/yolov6/yolov6_l_fast_1xb32-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov6_l_20230108_005634.json) | +| YOLOv7-tiny | 100(78) | 6.57 | 6.02 | Coco | 0.549 | 0.568 | [config](/projects/misc/ionogram_detection/yolov7/yolov7_tiny_fast_1xb16-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov7_tiny_20230215_202837.json) | +| YOLOv7-x | 100(58) | 94.27 | 70.85 | Coco | 0.602 | 0.595 | [config](/projects/misc/ionogram_detection/yolov7/yolov7_x_fast_1xb16-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/yolov7_x_20230110_165832.json) | +| rtmdet-tiny | 100(100) | 8.03 | 4.88 | Coco | 0.582 | 0.589 | [config](/projects/misc/ionogram_detection/rtmdet/rtmdet_tiny_fast_1xb32-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/rtmdet_tiny_20230310_125440.json) | +| rtmdet-s | 100(92) | 14.76 | 8.86 | Coco | 0.588 | 0.585 | [config](/projects/misc/ionogram_detection/rtmdet/rtmdet_s_fast_1xb32-100e_ionogram.py) | [log](https://github.com/VoyagerXvoyagerx/Ionogram_detection/blob/main/logs/rtmdet_s_20230310_163853.json) | diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/complexity_analysis.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/complexity_analysis.md new file mode 100644 index 0000000000000000000000000000000000000000..ae7989df280f54c74a4dc355305b1407be14965f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/complexity_analysis.md @@ -0,0 +1,120 @@ +# Model Complexity Analysis + +We provide a `tools/analysis_tools/get_flops.py` script to help with the complexity analysis for models of MMYOLO. +Currently, it provides the interfaces to compute parameter, activation and flops of the given model, +and supports printing the related information layer-by-layer in terms of network structure or table. + +The commands as follows: + +```shell +python tools/analysis_tools/get_flops.py + ${CONFIG_FILE} \ # config file path + [--shape ${IMAGE_SIZE}] \ # input image size (int), default 640*640 + [--show-arch ${ARCH_DISPLAY}] \ # print related information by network layers + [--not-show-table ${TABLE_DISPLAY}] \ # print related information by table + [--cfg-options ${CFG_OPTIONS}] # config file option +# [] stands for optional parameter, do not type [] when actually entering the command line +``` + +Let's take the `rtmdet_s_syncbn_fast_8xb32-300e_coco.py` config file in RTMDet as an example to show how this script can be used: + +## Usage Example 1: Print Flops, Parameters and related information by table + +```shell +python tools/analysis_tools/get_flops.py configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py +``` + +Output: + +```python +============================== +Input shape: torch.Size([640, 640]) +Model Flops: 14.835G +Model Parameters: 8.887M +============================== +``` + +| module | #parameters or shape | #flops | #activations | +| :-------------------------------- | :------------------- | :------ | :----------: | +| model | 8.887M | 14.835G | 35.676M | +| backbone | 4.378M | 5.416G | 22.529M | +| backbone.stem | 7.472K | 0.765G | 6.554M | +| backbone.stem.0 | 0.464K | 47.514M | 1.638M | +| backbone.stem.1 | 2.336K | 0.239G | 1.638M | +| backbone.stem.2 | 4.672K | 0.478G | 3.277M | +| backbone.stage1 | 42.4K | 0.981G | 7.373M | +| backbone.stage1.0 | 18.56K | 0.475G | 1.638M | +| backbone.stage1.1 | 23.84K | 0.505G | 5.734M | +| backbone.stage2 | 0.21M | 1.237G | 4.915M | +| backbone.stage2.0 | 73.984K | 0.473G | 0.819M | +| backbone.stage2.1 | 0.136M | 0.764G | 4.096M | +| backbone.stage3 | 0.829M | 1.221G | 2.458M | +| backbone.stage3.0 | 0.295M | 0.473G | 0.41M | +| backbone.stage3.1 | 0.534M | 0.749G | 2.048M | +| backbone.stage4 | 3.29M | 1.211G | 1.229M | +| backbone.stage4.0 | 1.181M | 0.472G | 0.205M | +| backbone.stage4.1 | 0.657M | 0.263G | 0.307M | +| backbone.stage4.2 | 1.452M | 0.476G | 0.717M | +| neck | 3.883M | 4.366G | 8.141M | +| neck.reduce_layers.2 | 0.132M | 52.634M | 0.102M | +| neck.reduce_layers.2.conv | 0.131M | 52.429M | 0.102M | +| neck.reduce_layers.2.bn | 0.512K | 0.205M | 0 | +| neck.top_down_layers | 0.491M | 1.23G | 4.506M | +| neck.top_down_layers.0 | 0.398M | 0.638G | 1.638M | +| neck.top_down_layers.1 | 92.608K | 0.593G | 2.867M | +| neck.downsample_layers | 0.738M | 0.472G | 0.307M | +| neck.downsample_layers.0 | 0.148M | 0.236G | 0.205M | +| neck.downsample_layers.1 | 0.59M | 0.236G | 0.102M | +| neck.bottom_up_layers | 1.49M | 0.956G | 2.15M | +| neck.bottom_up_layers.0 | 0.3M | 0.48G | 1.434M | +| neck.bottom_up_layers.1 | 1.19M | 0.476G | 0.717M | +| neck.out_layers | 1.033M | 1.654G | 1.075M | +| neck.out_layers.0 | 0.148M | 0.945G | 0.819M | +| neck.out_layers.1 | 0.295M | 0.472G | 0.205M | +| neck.out_layers.2 | 0.59M | 0.236G | 51.2K | +| neck.upsample_layers | | 1.229M | 0 | +| neck.upsample_layers.0 | | 0.41M | 0 | +| neck.upsample_layers.1 | | 0.819M | 0 | +| bbox_head.head_module | 0.625M | 5.053G | 5.006M | +| bbox_head.head_module.cls_convs | 0.296M | 2.482G | 2.15M | +| bbox_head.head_module.cls_convs.0 | 0.295M | 2.481G | 2.15M | +| bbox_head.head_module.cls_convs.1 | 0.512K | 0.819M | 0 | +| bbox_head.head_module.cls_convs.2 | 0.512K | 0.205M | 0 | +| bbox_head.head_module.reg_convs | 0.296M | 2.482G | 2.15M | +| bbox_head.head_module.reg_convs.0 | 0.295M | 2.481G | 2.15M | +| bbox_head.head_module.reg_convs.1 | 0.512K | 0.819M | 0 | +| bbox_head.head_module.reg_convs.2 | 0.512K | 0.205M | 0 | +| bbox_head.head_module.rtm_cls | 30.96K | 86.016M | 0.672M | +| bbox_head.head_module.rtm_cls.0 | 10.32K | 65.536M | 0.512M | +| bbox_head.head_module.rtm_cls.1 | 10.32K | 16.384M | 0.128M | +| bbox_head.head_module.rtm_cls.2 | 10.32K | 4.096M | 32K | +| bbox_head.head_module.rtm_reg | 1.548K | 4.301M | 33.6K | +| bbox_head.head_module.rtm_reg.0 | 0.516K | 3.277M | 25.6K | +| bbox_head.head_module.rtm_reg.1 | 0.516K | 0.819M | 6.4K | +| bbox_head.head_module.rtm_reg.2 | 0.516K | 0.205M | 1.6K | + +## Usage Example 2: Print related information by network layers + +```shell +python tools/analysis_tools/get_flops.py configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py --show-arch +``` + +Due to the complex structure of RTMDet, the output is long. +The following shows only the output from bbox_head.head_module.rtm_reg section: + +```python +(rtm_reg): ModuleList( + #params: 1.55K, #flops: 4.3M, #acts: 33.6K + (0): Conv2d( + 128, 4, kernel_size=(1, 1), stride=(1, 1) + #params: 0.52K, #flops: 3.28M, #acts: 25.6K + ) + (1): Conv2d( + 128, 4, kernel_size=(1, 1), stride=(1, 1) + #params: 0.52K, #flops: 0.82M, #acts: 6.4K + ) + (2): Conv2d( + 128, 4, kernel_size=(1, 1), stride=(1, 1) + #params: 0.52K, #flops: 0.2M, #acts: 1.6K + ) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/contributing.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/contributing.md new file mode 100644 index 0000000000000000000000000000000000000000..9efb8871b2ca2dbd637867aa24979380662be07d --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/contributing.md @@ -0,0 +1,314 @@ +# Contributing to OpenMMLab + +Welcome to the MMYOLO community, we are committed to building a cutting-edge computer vision foundational library, and all kinds of contributions are welcomed, including but not limited to + +**Fix bug** + +You can directly post a Pull Request to fix typos in code or documents + +The steps to fix the bug of code implementation are as follows. + +1. If the modification involves significant changes, you should create an issue first and describe the error information and how to trigger the bug. Other developers will discuss it with you and propose a proper solution. + +2. Posting a pull request after fixing the bug and adding the corresponding unit test. + +**New Feature or Enhancement** + +1. If the modification involves significant changes, you should create an issue to discuss with our developers to propose a proper design. +2. Post a Pull Request after implementing the new feature or enhancement and add the corresponding unit test. + +**Document** + +You can directly post a pull request to fix documents. If you want to add a document, you should first create an issue to check if it is reasonable. + +## Preparation + +The commands for processing pull requests are implemented using Git, and this chapter details `Git Configuration` and `associated GitHub`. + +### 1. Git Configuration + +First, make sure you have Git installed on your computer. For Linux systems and macOS systems, Git is generally installed by default. If it is not installed, it can be downloaded at [Git-Downloads](https://git-scm.com/downloads). + +```shell +# view the Git version +git --version +``` + +Second, check your `Git Config` + +```shell +# view the Git config +git config --global --list +``` + +If `user.name` and `user.email` are empty, run the command. + +```shell +git config --global user.name "Change your username here" +git config --global user.email "Change your useremail here" +``` + +Finally, run the command in `git bash` or `terminal` to generate the key file. After the generation is successful, a `.ssh` file will appear in the user directory, and `id_rsa.pub` is the public key file. + +```shell +# useremail is GitHub's email address +ssh-keygen -t rsa -C "useremail" +``` + +### 2. Associated GitHub + +First, open `id_rsa.pub` and copy the entire contents. + +Second, log in to your GitHub account to set it up. + + + +Click `New SSH key` to add a new SSH keys, and paste the copied content into Key. + + + +Finally, verify that SSH matches the GitHub account by running the command in `git bash` or `terminal`. If it matches, enter `yes` to succeed. + +```shell +ssh -T git@github.com +``` + + + +## Pull Request Workflow + +If you're not familiar with Pull Request, don't worry! The following guidance will tell you how to create a Pull Request step by step. If you want to dive into the development mode of Pull Request, you can refer to the [official documents](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests) + +### 1. Fork and clone + +If you are posting a pull request for the first time, you should fork the OpenMMLab repositories by clicking the **Fork** button in the top right corner of the GitHub page, and the forked repositories will appear under your GitHub profile. + + + +Then, you can clone the repositories to local: + +```shell +git clone git@github.com:{username}/mmyolo.git +``` + +After that, you should get into the project folder and add official repository as the upstream repository. + +```bash +cd mmyolo +git remote add upstream git@github.com:open-mmlab/mmyolo +``` + +Check whether the remote repository has been added successfully by `git remote -v` + +```bash +origin git@github.com:{username}/mmyolo.git (fetch) +origin git@github.com:{username}/mmyolo.git (push) +upstream git@github.com:open-mmlab/mmyolo (fetch) +upstream git@github.com:open-mmlab/mmyolo (push) +``` + +```{note} +Here's a brief introduction to the origin and upstream. When we use "git clone", we create an "origin" remote by default, which points to the repository cloned from. As for "upstream", we add it ourselves to point to the target repository. Of course, if you don't like the name "upstream", you could name it as you wish. Usually, we'll push the code to "origin". If the pushed code conflicts with the latest code in official("upstream"), we should pull the latest code from upstream to resolve the conflicts, and then push to "origin" again. The posted Pull Request will be updated automatically. +``` + +### 2. Configure pre-commit + +You should configure [pre-commit](https://pre-commit.com/#intro) in the local development environment to make sure the code style matches that of OpenMMLab. **Note**: The following code should be executed under the MMYOLO directory. + +```shell +pip install -U pre-commit +pre-commit install +``` + +Check that pre-commit is configured successfully, and install the hooks defined in `.pre-commit-config.yaml`. + +```shell +pre-commit run --all-files +``` + + + + + +```{note} +Chinese users may fail to download the pre-commit hooks due to the network issue. In this case, you could download these hooks from gitee by setting the .pre-commit-config-zh-cn.yaml + +pre-commit install -c .pre-commit-config-zh-cn.yaml +pre-commit run --all-files -c .pre-commit-config-zh-cn.yaml +``` + +If the installation process is interrupted, you can repeatedly run `pre-commit run ... ` to continue the installation. + +If the code does not conform to the code style specification, pre-commit will raise a warning and fixes some of the errors automatically. + + + +If we want to commit our code bypassing the pre-commit hook, we can use the `--no-verify` option(**only for temporarily commit**). + +```shell +git commit -m "xxx" --no-verify +``` + +### 3. Create a development branch + +After configuring the pre-commit, we should create a branch based on the dev branch to develop the new feature or fix the bug. The proposed branch name is `username/pr_name` + +```shell +git checkout -b yhc/refactor_contributing_doc +``` + +In subsequent development, if the dev branch of the local repository is behind the dev branch of "upstream", we need to pull the upstream for synchronization, and then execute the above command: + +```shell +git pull upstream dev +``` + +### 4. Commit the code and pass the unit test + +- MMYOLO introduces mypy to do static type checking to increase the robustness of the code. Therefore, we need to add Type Hints to our code and pass the mypy check. If you are not familiar with Type Hints, you can refer to [this tutorial](https://docs.python.org/3/library/typing.html). + +- The committed code should pass through the unit test + + ```shell + # Pass all unit tests + pytest tests + + # Pass the unit test of yolov5_coco dataset + pytest tests/test_datasets/test_yolov5_coco.py + ``` + + If the unit test fails for lack of dependencies, you can install the dependencies referring to the [guidance](#unit-test) + +- If the documents are modified/added, we should check the rendering result referring to [guidance](#document-rendering) + +### 5. Push the code to remote + +We could push the local commits to remote after passing through the check of unit test and pre-commit. You can associate the local branch with remote branch by adding `-u` option. + +```shell +git push -u origin {branch_name} +``` + +This will allow you to use the `git push` command to push code directly next time, without having to specify a branch or the remote repository. + +### 6. Create a Pull Request + +(1) Create a pull request in GitHub's Pull request interface + + + +(2) Modify the PR description according to the guidelines so that other developers can better understand your changes. + +```{note} +The *base* branch should be modified to *dev* branch. +``` + + + +Find more details about Pull Request description in [pull request guidelines](#pr-specs). + +**note** + +(a) The Pull Request description should contain the reason for the change, the content of the change, and the impact of the change, and be associated with the relevant Issue (see [documentation](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)) + +(b) If it is your first contribution, please sign the CLA + + + +(c) Check whether the Pull Request pass through the CI + + + +MMYOLO will run unit test for the posted Pull Request on Linux, based on different versions of Python, and PyTorch to make sure the code is correct. We can see the specific test information by clicking `Details` in the above image so that we can modify the code. + +(3) If the Pull Request passes the CI, then you can wait for the review from other developers. You'll modify the code based on the reviewer's comments, and repeat the steps [4](#4-commit-the-code-and-pass-the-unit-test)-[5](#5-push-the-code-to-remote) until all reviewers approve it. Then, we will merge it ASAP. + + + +### 7. Resolve conflicts + +If your local branch conflicts with the latest dev branch of "upstream", you'll need to resolove them. There are two ways to do this: + +```shell +git fetch --all --prune +git rebase upstream/dev +``` + +or + +```shell +git fetch --all --prune +git merge upstream/dev +``` + +If you are very good at handling conflicts, then you can use rebase to resolve conflicts, as this will keep your commit logs tidy. If you are unfamiliar with `rebase`, you can use `merge` to resolve conflicts. + +## Guidance + +### Unit test + +We should also make sure the committed code will not decrease the coverage of unit test, we could run the following command to check the coverage of unit test: + +```shell +python -m coverage run -m pytest /path/to/test_file +python -m coverage html +# check file in htmlcov/index.html +``` + +### Document rendering + +If the documents are modified/added, we should check the rendering result. We could install the dependencies and run the following command to render the documents and check the results: + +```shell +pip install -r requirements/docs.txt +cd docs/zh_cn/ +# or docs/en +make html +# check file in ./docs/zh_cn/_build/html/index.html +``` + +## Code style + +### Python + +We adopt [PEP8](https://www.python.org/dev/peps/pep-0008/) as the preferred code style. + +We use the following tools for linting and formatting: + +- [flake8](https://github.com/PyCQA/flake8): A wrapper around some linter tools. +- [isort](https://github.com/timothycrosley/isort): A Python utility to sort imports. +- [yapf](https://github.com/google/yapf): A formatter for Python files. +- [codespell](https://github.com/codespell-project/codespell): A Python utility to fix common misspellings in text files. +- [mdformat](https://github.com/executablebooks/mdformat): Mdformat is an opinionated Markdown formatter that can be used to enforce a consistent style in Markdown files. +- [docformatter](https://github.com/myint/docformatter): A formatter to format docstring. + +Style configurations of yapf and isort can be found in [setup.cfg](../../../setup.cfg). + +We use [pre-commit hook](https://pre-commit.com/) that checks and formats for `flake8`, `yapf`, `isort`, `trailing whitespaces`, `markdown files`, +fixes `end-of-files`, `double-quoted-strings`, `python-encoding-pragma`, `mixed-line-ending`, sorts `requirments.txt` automatically on every commit. +The config for a pre-commit hook is stored in [.pre-commit-config](../../../.pre-commit-config.yaml). + +### C++ and CUDA + +We follow the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html). + +## PR Specs + +1. Use [pre-commit](https://pre-commit.com) hook to avoid issues of code style + +2. One short-time branch should be matched with only one PR + +3. Accomplish a detailed change in one PR. Avoid large PR + + - Bad: Support Faster R-CNN + - Acceptable: Add a box head to Faster R-CNN + - Good: Add a parameter to box head to support custom conv-layer number + +4. Provide clear and significant commit message + +5. Provide clear and meaningful PR description + + - Task name should be clarified in title. The general format is: \[Prefix\] Short description of the PR (Suffix) + - Prefix: add new feature \[Feature\], fix bug \[Fix\], related to documents \[Docs\], in developing \[WIP\] (which will not be reviewed temporarily) + - Introduce main changes, results and influences on other modules in short description + - Associate related issues and pull requests with a milestone diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/dataset_preparation.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/dataset_preparation.md new file mode 100644 index 0000000000000000000000000000000000000000..af670d89a4214bd440bd39b4faf9fc37fe7d5286 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/dataset_preparation.md @@ -0,0 +1,145 @@ +# Dataset preparation and description + +## DOTA Dataset + +### Download dataset + +The DOTA dataset can be downloaded from [DOTA](https://captain-whu.github.io/DOTA/dataset.html) +or [OpenDataLab](https://opendatalab.org.cn/DOTA_V1.0). + +We recommend using [OpenDataLab](https://opendatalab.org.cn/DOTA_V1.0) to download the dataset, as the folder structure has already been arranged as needed and can be directly extracted without the need to adjust the folder structure. + +Please unzip the file and place it in the following structure. + +```none +${DATA_ROOT} +├── train +│ ├── images +│ │ ├── P0000.png +│ │ ├── ... +│ ├── labelTxt-v1.0 +│ │ ├── labelTxt +│ │ │ ├── P0000.txt +│ │ │ ├── ... +│ │ ├── trainset_reclabelTxt +│ │ │ ├── P0000.txt +│ │ │ ├── ... +├── val +│ ├── images +│ │ ├── P0003.png +│ │ ├── ... +│ ├── labelTxt-v1.0 +│ │ ├── labelTxt +│ │ │ ├── P0003.txt +│ │ │ ├── ... +│ │ ├── valset_reclabelTxt +│ │ │ ├── P0003.txt +│ │ │ ├── ... +├── test +│ ├── images +│ │ ├── P0006.png +│ │ ├── ... + +``` + +The folder ending with reclabelTxt stores the labels for the horizontal boxes and is not used when slicing. + +### Split DOTA dataset + +Script `tools/dataset_converters/dota/dota_split.py` can split and prepare DOTA dataset. + +```shell +python tools/dataset_converters/dota/dota_split.py \ + [--splt-config ${SPLIT_CONFIG}] \ + [--data-root ${DATA_ROOT}] \ + [--out-dir ${OUT_DIR}] \ + [--ann-subdir ${ANN_SUBDIR}] \ + [--phase ${DATASET_PHASE}] \ + [--nproc ${NPROC}] \ + [--save-ext ${SAVE_EXT}] \ + [--overwrite] +``` + +shapely is required, please install shapely first by `pip install shapely`. + +**Description of all parameters**： + +- `--split-config` : The split config for image slicing. +- `--data-root`: Root dir of DOTA dataset. +- `--out-dir`: Output dir for split result. +- `--ann-subdir`: The subdir name for annotation. Defaults to `labelTxt-v1.0`. +- `--phase`: Phase of the data set to be prepared. Defaults to `trainval test` +- `--nproc`: Number of processes. Defaults to 8. +- `--save-ext`: Extension of the saved image. Defaults to `png` +- `--overwrite`: Whether to allow overwrite if annotation folder exist. + +Based on the configuration in the DOTA paper, we provide two commonly used split config. + +- `./split_config/single_scale.json` means single-scale split. +- `./split_config/multi_scale.json` means multi-scale split. + +DOTA dataset usually uses the trainval set for training and the test set for online evaluation, since most papers +provide the results of online evaluation. If you want to evaluate the model performance locally firstly, please split +the train set and val set. + +Examples: + +Split DOTA trainval set and test set with single scale. + +```shell +python tools/dataset_converters/dota/dota_split.py + --split-config 'tools/dataset_converters/dota/split_config/single_scale.json' + --data-root ${DATA_ROOT} \ + --out-dir ${OUT_DIR} +``` + +If you want to split DOTA-v1.5 dataset, which have different annotation dir 'labelTxt-v1.5'. + +```shell +python tools/dataset_converters/dota/dota_split.py + --split-config 'tools/dataset_converters/dota/split_config/single_scale.json' + --data-root ${DATA_ROOT} \ + --out-dir ${OUT_DIR} \ + --ann-subdir 'labelTxt-v1.5' +``` + +If you want to split DOTA train and val set with single scale. + +```shell +python tools/dataset_converters/dota/dota_split.py + --split-config 'tools/dataset_converters/dota/split_config/single_scale.json' + --data-root ${DATA_ROOT} \ + --phase train val \ + --out-dir ${OUT_DIR} +``` + +For multi scale split: + +```shell +python tools/dataset_converters/dota/dota_split.py + --split-config 'tools/dataset_converters/dota/split_config/multi_scale.json' + --data-root ${DATA_ROOT} \ + --out-dir ${OUT_DIR} +``` + +The new data structure is as follows: + +```none +${OUT_DIR} +├── trainval +│ ├── images +│ │ ├── P0000__1024__0___0.png +│ │ ├── ... +│ ├── annfiles +│ │ ├── P0000__1024__0___0.txt +│ │ ├── ... +├── test +│ ├── images +│ │ ├── P0006__1024__0___0.png +│ │ ├── ... +│ ├── annfiles +│ │ ├── P0006__1024__0___0.txt +│ │ ├── ... +``` + +Then change `data_root` to ${OUT_DIR}. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/easydeploy_guide.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/easydeploy_guide.md new file mode 100644 index 0000000000000000000000000000000000000000..46fab865340f6db1eb52146de9459078b68f1319 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/easydeploy_guide.md @@ -0,0 +1 @@ +# EasyDeploy Deployment diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/index.rst b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..f21f353c8c64d457e21c79b4af1c75eae9715174 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/index.rst @@ -0,0 +1,16 @@ +MMDeploy deployment tutorial +******************************** + +.. toctree:: + :maxdepth: 1 + + mmdeploy_guide.md + mmdeploy_yolov5.md + +EasyDeploy deployment tutorial +************************************ + +.. toctree:: + :maxdepth: 1 + + easydeploy_guide.md diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/mmdeploy_guide.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/mmdeploy_guide.md new file mode 100644 index 0000000000000000000000000000000000000000..096d39fbc9bd6ee46309332339cbcdca2009c098 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/mmdeploy_guide.md @@ -0,0 +1,414 @@ +# Basic Deployment Guide + +## Introduction of MMDeploy + +MMDeploy is an open-source deep learning model deployment toolset. It is a part of the [OpenMMLab](https://openmmlab.com/) project, and provides **a unified experience of exporting different models** to various platforms and devices of the OpenMMLab series libraries. Using MMDeploy, developers can easily export the specific compiled SDK they need from the training result, which saves a lot of effort. + +More detailed introduction and guides can be found [here](https://mmdeploy.readthedocs.io/en/latest/get_started.html) + +## Supported Algorithms + +Currently our deployment kit supports on the following models and backends: + +| Model | Task | OnnxRuntime | TensorRT | Model config | +| :----- | :-------------- | :---------: | :------: | :---------------------------------------------------------------------: | +| YOLOv5 | ObjectDetection | Y | Y | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5) | +| YOLOv6 | ObjectDetection | Y | Y | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov6) | +| YOLOX | ObjectDetection | Y | Y | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolox) | +| RTMDet | ObjectDetection | Y | Y | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/rtmdet) | + +Note: ncnn and other inference backends support are coming soon. + +## Installation + +Please install mmdeploy by following [this](https://mmdeploy.readthedocs.io/en/latest/get_started.html) guide. + +```{note} +If you install mmdeploy prebuilt package, please also clone its repository by 'git clone https://github.com/open-mmlab/mmdeploy.git --depth=1' to get the 'tools' file for deployment. +``` + +## How to Write Config for MMYOLO + +All config files related to the deployment are located at [`configs/deploy`](../../../configs/deploy/). + +You only need to change the relative data processing part in the model config file to support either static or dynamic input for your model. Besides, MMDeploy integrates the post-processing parts as customized ops, you can modify the strategy in `post_processing` parameter in `codebase_config`. + +Here is the detail description: + +```python +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +``` + +- `score_threshold`: set the score threshold to filter candidate bboxes before `nms` +- `confidence_threshold`: set the confidence threshold to filter candidate bboxes before `nms` +- `iou_threshold`: set the `iou` threshold for removing duplicates in `nms` +- `max_output_boxes_per_class`: set the maximum number of bboxes for each class +- `pre_top_k`: set the number of fixedcandidate bboxes before `nms`, sorted by scores +- `keep_top_k`: set the number of output candidate bboxs after `nms` +- `background_label_id`: set to `-1` as MMYOLO has no background class information + +### Configuration for Static Inputs + +#### 1. Model Config + +Taking `YOLOv5` of MMYOLO as an example, here are the details: + +```python +_base_ = '../../yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=False, + use_mini_pad=False, + ), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +test_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) +``` + +`_base_ = '../../yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py'` inherits the model config in the training stage. + +`test_pipeline` adds the data processing piple for the deployment, `LetterResize` controls the size of the input images and the input for the converted model + +`test_dataloader` adds the dataloader config for the deployment, `batch_shapes_cfg` decides whether to use the `batch_shapes` strategy. More details can be found at [yolov5 configs](../user_guides/config.md) + +#### 2. Deployment Config + +Here we still use the `YOLOv5` in MMYOLO as the example. We can use [`detection_onnxruntime_static.py`](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy/detection_onnxruntime_static.py) as the config to deploy `YOLOv5` to `ONNXRuntime` with static inputs. + +```python +_base_ = ['./base_static.py'] +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +backend_config = dict(type='onnxruntime') +``` + +`backend_config` indicates the deployment backend with `type='onnxruntime'`, other information can be referred from the third section. + +To deploy the `YOLOv5` to `TensorRT`, please refer to the [`detection_tensorrt_static-640x640.py`](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy/detection_tensorrt_static-640x640.py) as follows. + +```python +_base_ = ['./base_static.py'] +onnx_config = dict(input_shape=(640, 640)) +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=False, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 640, 640], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 640, 640]))) + ]) +use_efficientnms = False +``` + +`backend_config` indices the backend with `type='tensorrt'`. + +Different from `ONNXRuntime` deployment configuration, `TensorRT` needs to specify the input image size and the parameters required to build the engine file, including: + +- `onnx_config` specifies the input shape as `input_shape=(640, 640)` +- `fp16_mode=False` and `max_workspace_size=1 << 30` in `backend_config['common_config']` indicates whether to build the engine in the parameter format of `fp16`, and the maximum video memory for the current `gpu` device, respectively. The unit is in `GB`. For detailed configuration of `fp16`, please refer to the [`detection_tensorrt-fp16_static-640x640.py`](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy/detection_tensorrt-fp16_static-640x640.py) +- The `min_shape`/`opt_shape`/`max_shape` in `backend_config['model_inputs']['input_shapes']['input']` should remain the same under static input, the default is `[1, 3, 640, 640]`. + +`use_efficientnms` is a new configuration introduced by the `MMYOLO` series, indicating whether to enable `Efficient NMS Plugin` to replace `TRTBatchedNMS plugin` in `MMDeploy` when exporting `onnx`. + +You can refer to the official [efficient NMS plugins](https://github.com/NVIDIA/TensorRT/blob/main/plugin/efficientNMSPlugin/README.md) by `TensorRT` for more details. + +Note: this out-of-box feature is **only available in TensorRT>=8.0**, no need to compile it by yourself. + +### Configuration for Dynamic Inputs + +#### 1. Model Config + +When you deploy a dynamic input model, you don't need to modify any model configuration files but the deployment configuration files. + +#### 2. Deployment Config + +To deploy the `YOLOv5` in MMYOLO to `ONNXRuntime`, please refer to the [`detection_onnxruntime_dynamic.py`](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy/detection_onnxruntime_dynamic.py). + +```python +_base_ = ['./base_dynamic.py'] +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +backend_config = dict(type='onnxruntime') +``` + +`backend_config` indicates the backend with `type='onnxruntime'`. Other parameters stay the same as the static input section. + +To deploy the `YOLOv5` to `TensorRT`, please refer to the [`detection_tensorrt_dynamic-192x192-960x960.py`](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py). + +```python +_base_ = ['./base_dynamic.py'] +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=False, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 192, 192], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 960, 960]))) + ]) +use_efficientnms = False +``` + +`backend_config` indicates the backend with `type='tensorrt'`. Since the dynamic and static inputs are different in `TensorRT`, please check the details at [TensorRT dynamic input official introduction](https://docs.nvidia.com/deeplearning/tensorrt/archives/tensorrt-843/developer-guide/index.html#work_dynamic_shapes). + +`TensorRT` deployment requires you to specify `min_shape`, `opt_shape` , and `max_shape`. `TensorRT` limits the size of the input image between `min_shape` and `max_shape`. + +`min_shape` is the minimum size of the input image. `opt_shape` is the common size of the input image, inference performance is best under this size. `max_shape` is the maximum size of the input image. + +`use_efficientnms` configuration is the same as the `TensorRT` static input configuration in the previous section. + +### INT8 Quantization Support + +Note: Int8 quantization support will soon be released. + +## How to Convert Model + +### Usage + +#### Deploy with MMDeploy Tools + +Set the root directory of `MMDeploy` as an env parameter `MMDEPLOY_DIR` using `export MMDEPLOY_DIR=/the/root/path/of/MMDeploy` command. + +```shell +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + ${DEPLOY_CFG_PATH} \ + ${MODEL_CFG_PATH} \ + ${MODEL_CHECKPOINT_PATH} \ + ${INPUT_IMG} \ + --test-img ${TEST_IMG} \ + --work-dir ${WORK_DIR} \ + --calib-dataset-cfg ${CALIB_DATA_CFG} \ + --device ${DEVICE} \ + --log-level INFO \ + --show \ + --dump-info +``` + +### Parameter Description + +- `deploy_cfg`: set the deployment config path of MMDeploy for the model, including the type of inference framework, whether quantize, whether the input shape is dynamic, etc. There may be a reference relationship between configuration files, e.g. `configs/deploy/detection_onnxruntime_static.py` +- `model_cfg`: set the MMYOLO model config path, e.g. `configs/deploy/model/yolov5_s-deploy.py`, regardless of the path to MMDeploy +- `checkpoint`: set the torch model path. It can start with `http/https`, more details are available in `mmengine.fileio` apis +- `img`: set the path to the image or point cloud file used for testing during model conversion +- `--test-img`: set the image file that used to test model. If not specified, it will be set to `None` +- `--work-dir`: set the work directory that used to save logs and models +- `--calib-dataset-cfg`: use for calibration only for INT8 mode. If not specified, it will be set to None and use “val” dataset in model config for calibration +- `--device`: set the device used for model conversion. The default is `cpu`, for TensorRT used `cuda:0` +- `--log-level`: set log level which in `'CRITICAL', 'FATAL', 'ERROR', 'WARN', 'WARNING', 'INFO', 'DEBUG', 'NOTSET'`. If not specified, it will be set to `INFO` +- `--show`: show the result on screen or not +- `--dump-info`: output SDK information or not + +#### Deploy with MMDeploy API + +Suppose the working directory is the root path of mmyolo. Take [YoloV5](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py) model as an example. You can download its checkpoint from [here](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth), and then convert it to onnx model as follows: + +```python +from mmdeploy.apis import torch2onnx +from mmdeploy.backend.sdk.export_info import export2SDK + +img = 'demo/demo.jpg' +work_dir = 'mmdeploy_models/mmyolo/onnx' +save_file = 'end2end.onnx' +deploy_cfg = 'configs/deploy/detection_onnxruntime_dynamic.py' +model_cfg = 'configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model_checkpoint = 'checkpoints/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' +device = 'cpu' + +# 1. convert model to onnx +torch2onnx(img, work_dir, save_file, deploy_cfg, model_cfg, + model_checkpoint, device) + +# 2. extract pipeline info for inference by MMDeploy SDK +export2SDK(deploy_cfg, model_cfg, work_dir, pth=model_checkpoint, + device=device) +``` + +## Model specification + +Before moving on to model inference chapter, let's know more about the converted result structure which is very important for model inference. It is saved in the directory specified with `--wodk_dir`. + +The converted results are saved in the working directory `mmdeploy_models/mmyolo/onnx` in the previous example. It includes: + +``` +mmdeploy_models/mmyolo/onnx +├── deploy.json +├── detail.json +├── end2end.onnx +└── pipeline.json +``` + +in which, + +- **end2end.onnx**: backend model which can be inferred by ONNX Runtime +- ***xxx*.json**: the necessary information for mmdeploy SDK + +The whole package **mmdeploy_models/mmyolo/onnx** is defined as **mmdeploy SDK model**, i.e., **mmdeploy SDK model** includes both backend model and inference meta information. + +## Model inference + +### Backend model inference + +Take the previous converted `end2end.onnx` model as an example, you can use the following code to inference the model and visualize the results. + +```python +from mmdeploy.apis.utils import build_task_processor +from mmdeploy.utils import get_input_shape, load_config +import torch + +deploy_cfg = 'configs/deploy/detection_onnxruntime_dynamic.py' +model_cfg = 'configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' +device = 'cpu' +backend_model = ['mmdeploy_models/mmyolo/onnx/end2end.onnx'] +image = 'demo/demo.jpg' + +# read deploy_cfg and model_cfg +deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg) + +# build task and backend model +task_processor = build_task_processor(model_cfg, deploy_cfg, device) +model = task_processor.build_backend_model(backend_model) + +# process input image +input_shape = get_input_shape(deploy_cfg) +model_inputs, _ = task_processor.create_input(image, input_shape) + +# do model inference +with torch.no_grad(): + result = model.test_step(model_inputs) + +# visualize results +task_processor.visualize( + image=image, + model=model, + result=result[0], + window_name='visualize', + output_file='work_dir/output_detection.png') +``` + +With the above code, you can find the inference result `output_detection.png` in `work_dir`. + +### SDK model inference + +You can also perform SDK model inference like following, + +```python +from mmdeploy_runtime import Detector +import cv2 + +img = cv2.imread('demo/demo.jpg') + +# create a detector +detector = Detector(model_path='mmdeploy_models/mmyolo/onnx', + device_name='cpu', device_id=0) +# perform inference +bboxes, labels, masks = detector(img) + +# visualize inference result +indices = [i for i in range(len(bboxes))] +for index, bbox, label_id in zip(indices, bboxes, labels): + [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4] + if score < 0.3: + continue + + cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0)) + +cv2.imwrite('work_dir/output_detection.png', img) +``` + +Besides python API, mmdeploy SDK also provides other FFI (Foreign Function Interface), such as C, C++, C#, Java and so on. You can learn their usage from [demos](https://github.com/open-mmlab/mmdeploy/tree/main/demo). + +## How to Evaluate Model + +### Usage + +After the model is converted to your backend, you can use `${MMDEPLOY_DIR}/tools/test.py` to evaluate the performance. + +```shell +python3 ${MMDEPLOY_DIR}/tools/test.py \ + ${DEPLOY_CFG} \ + ${MODEL_CFG} \ + --model ${BACKEND_MODEL_FILES} \ + --device ${DEVICE} \ + --work-dir ${WORK_DIR} \ + [--cfg-options ${CFG_OPTIONS}] \ + [--show] \ + [--show-dir ${OUTPUT_IMAGE_DIR}] \ + [--interval ${INTERVAL}] \ + [--wait-time ${WAIT_TIME}] \ + [--log2file work_dirs/output.txt] + [--speed-test] \ + [--warmup ${WARM_UP}] \ + [--log-interval ${LOG_INTERVERL}] \ + [--batch-size ${BATCH_SIZE}] \ + [--uri ${URI}] +``` + +### Parameter Description + +- `deploy_cfg`: set the deployment config file path. +- `model_cfg`: set the MMYOLO model config file path. +- `--model`: set the converted model. For example, if we exported a TensorRT model, we need to pass in the file path with the suffix ".engine". +- `--device`: indicate the device to run the model. Note that some backends limit the running devices. For example, TensorRT must run on CUDA. +- `--work-dir`: the directory to save the file containing evaluation metrics. +- `--cfg-options`: pass in additional configs, which will override the current deployment configs. +- `--show`: show the evaluation result on screen or not. +- `--show-dir`: save the evaluation result to this directory, valid only when specified. +- `--interval`: set the display interval between each two evaluation results. +- `--wait-time`: set the display time of each window. +- `--log2file`: log evaluation results and speed to file. +- `--speed-test`: test the inference speed or not. +- `--warmup`: warm up before speed test or not, works only when `speed-test` is specified. +- `--log-interval`: the interval between each log, works only when `speed-test` is specified. +- `--batch-size`: set the batch size for inference, which will override the `samples_per_gpu` in data config. The default value is `1`, however, not every model supports `batch_size > 1`. +- `--uri`: Remote ipv4:port or ipv6:port for inference on edge device. + +Note: other parameters in `${MMDEPLOY_DIR}/tools/test.py` are used for speed test, they will not affect the evaluation results. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/mmdeploy_yolov5.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/mmdeploy_yolov5.md new file mode 100644 index 0000000000000000000000000000000000000000..321a6734fe0a18f35e88b5f31e28be6b3abc7ee5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/deploy/mmdeploy_yolov5.md @@ -0,0 +1,572 @@ +# YOLOv5 Deployment + +Please check the [basic_deployment_guide](mmdeploy_guide.md) to get familiar with the configurations. + +## Model Training and Validation + +TODO + +## MMDeploy Environment Setup + +Please check the installation document of `MMDeploy` at [build_from_source](https://github.com/open-mmlab/mmdeploy/blob/dev-1.x/docs/en/01-how-to-build/build_from_source.md). Please build both `MMDeploy` and the customized Ops to your specific platform. + +Note: please check at `MMDeploy` [FAQ](https://github.com/open-mmlab/mmdeploy/blob/dev-1.x/docs/en/faq.md) or create new issues in `MMDeploy` when you come across any problems. + +## How to Prepare Configuration File + +This deployment guide uses the `YOLOv5` model trained on `COCO` dataset in MMYOLO to illustrate the whole process, including both static and dynamic inputs and different procedures for `TensorRT` and `ONNXRuntime`. + +### For Static Input + +#### 1. Model Config + +To deploy the model with static inputs, you need to ensure that the model inputs are in fixed size, e.g. the input size is set to `640x640` while uploading data in the test pipeline and test dataloader. + +Here is a example in [`yolov5_s-static.py`](https://github.com/open-mmlab/mmyolo/tree/main/configs/deploy/model/yolov5_s-static.py) + +```python +_base_ = '../../yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=False, + use_mini_pad=False, + ), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +test_dataloader = dict( + dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=None)) +``` + +As the `YOLOv5` will turn on `allow_scale_up` and `use_mini_pad` during the test to change the size of the input image in order to achieve higher accuracy. However, it will cause the input size mismatch problem when deploying in the static input model. + +Compared with the original configuration file, this configuration has been modified as follows: + +- turn off the settings related to reshaping the image in `test_pipeline`, e.g. setting `allow_scale_up=False` and `use_mini_pad=False` in `LetterResize` +- turn off the `batch_shapes` in `test_dataloader` as `batch_shapes_cfg=None`. + +#### 2. Deployment Cofnig + +To deploy the model to `ONNXRuntime`, please refer to the [`detection_onnxruntime_static.py`](https://github.com/open-mmlab/mmyolo/tree/main/configs/deploy/detection_onnxruntime_static.py) as follows: + +```python +_base_ = ['./base_static.py'] +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +backend_config = dict(type='onnxruntime') +``` + +The `post_processing` in the default configuration aligns the accuracy of the current model with the trained `pytorch` model. If you need to modify the relevant parameters, you can refer to the detailed introduction of [dasic_deployment_guide](mmdeploy_guide.md). + +To deploy the model to `TensorRT`, please refer to the [`detection_tensorrt_static-640x640.py`](https://github.com/open-mmlab/mmyolo/tree/main/configs/deploy/detection_tensorrt_static-640x640.p). + +```python +_base_ = ['./base_static.py'] +onnx_config = dict(input_shape=(640, 640)) +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=False, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 640, 640], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 640, 640]))) + ]) +use_efficientnms = False +``` + +In this guide, we use the default settings such as `input_shape=(640, 640)` and `fp16_mode=False` to build in network in `fp32` mode. Moreover, we set `max_workspace_size=1 << 30` for the gpu memory which allows `TensorRT` to build the engine with maximum `1GB` memory. + +### For Dynamic Input + +#### 1. Model Confige + +As `TensorRT` limits the minimum and maximum input size, we can use any size for the inputs when deploy the model in dynamic mode. In this way, we can keep the default settings in [`yolov5_s-v61_syncbn_8xb16-300e_coco.py`](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py). The data processing and dataloader parts are as follows. + +```python +batch_shapes_cfg = dict( + type='BatchShapePolicy', + batch_size=val_batch_size_per_gpu, + img_size=img_scale[0], + size_divisor=32, + extra_pad_ratio=0.5) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_per_gpu, + num_workers=val_num_workers, + persistent_workers=persistent_workers, + pin_memory=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, + data_prefix=dict(img='val2017/'), + ann_file='annotations/instances_val2017.json', + pipeline=test_pipeline, + batch_shapes_cfg=batch_shapes_cfg)) +``` + +We use `allow_scale_up=False` to control when the input small images will be upsampled or not in the initialization of `LetterResize`. At the same time, the default `use_mini_pad=False` turns off the minimum padding strategy of the image, and `val_dataloader['dataset']` is passed in` batch_shapes_cfg=batch_shapes_cfg` to ensure that the minimum padding is performed according to the input size in `batch`. These configs will change the dimensions of the input image, so the converted model can support dynamic inputs according to the above dataset loader when testing. + +#### 2. Deployment Cofnig + +To deploy the model to `ONNXRuntime`, please refer to the [`detection_onnxruntime_dynamic.py`](https://github.com/open-mmlab/mmyolo/blob/main/configs/deploy/detection_onnxruntime_dynamic.py) for more details. + +```python +_base_ = ['./base_dynamic.py'] +codebase_config = dict( + type='mmyolo', + task='ObjectDetection', + model_type='end2end', + post_processing=dict( + score_threshold=0.05, + confidence_threshold=0.005, + iou_threshold=0.5, + max_output_boxes_per_class=200, + pre_top_k=5000, + keep_top_k=100, + background_label_id=-1), + module=['mmyolo.deploy']) +backend_config = dict(type='onnxruntime') +``` + +Differs from the static input config we introduced in previous section, dynamic input config additionally inherits the `dynamic_axes`. The rest of the configuration stays the same as the static inputs. + +To deploy the model to `TensorRT`, please refer to the [`detection_tensorrt_dynamic-192x192-960x960.py`](https://github.com/open-mmlab/mmyolo/tree/main/configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py) for more details. + +```python +_base_ = ['./base_dynamic.py'] +backend_config = dict( + type='tensorrt', + common_config=dict(fp16_mode=False, max_workspace_size=1 << 30), + model_inputs=[ + dict( + input_shapes=dict( + input=dict( + min_shape=[1, 3, 192, 192], + opt_shape=[1, 3, 640, 640], + max_shape=[1, 3, 960, 960]))) + ]) +use_efficientnms = False +``` + +In our example, the network is built in `fp32` mode as `fp16_mode=False`, and the maximum graphic memory is `1GB` for building the `TensorRT` engine as `max_workspace_size=1 << 30`. + +At the same time, `min_shape=[1, 3, 192, 192]`, `opt_shape=[1, 3, 640, 640]`, and `max_shape=[1, 3, 960, 960]` in the default setting set the model with minimum input size to `192x192`, the maximum size to `960x960`, and the most common size to `640x640`. + +When you deploy the model, it can adopt to the input image dimensions automatically. + +## How to Convert Model + +Note: The `MMDeploy` root directory used in this guide is `/home/openmmlab/dev/mmdeploy`, please modify it to your `MMDeploy` directory. + +Use the following command to download the pretrained YOLOv5 weight and save it to your device: + +```shell +wget https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth -O /home/openmmlab/dev/mmdeploy/yolov5s.pth +``` + +Set the relevant env parameters using the following command as well: + +```shell +export MMDEPLOY_DIR=/home/openmmlab/dev/mmdeploy +export PATH_TO_CHECKPOINTS=/home/openmmlab/dev/mmdeploy/yolov5s.pth +``` + +### YOLOv5 Static Model Deployment + +#### ONNXRuntime + +```shell +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + configs/deploy/detection_onnxruntime_static.py \ + configs/deploy/model/yolov5_s-static.py \ + ${PATH_TO_CHECKPOINTS} \ + demo/demo.jpg \ + --work-dir work_dir \ + --show \ + --device cpu +``` + +#### TensorRT + +```shell +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + configs/deploy/detection_tensorrt_static-640x640.py \ + configs/deploy/model/yolov5_s-static.py \ + ${PATH_TO_CHECKPOINTS} \ + demo/demo.jpg \ + --work-dir work_dir \ + --show \ + --device cuda:0 +``` + +### YOLOv5 Dynamic Model Deployment + +#### ONNXRuntime + +```shell +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + configs/deploy/detection_onnxruntime_dynamic.py \ + configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py \ + ${PATH_TO_CHECKPOINTS} \ + demo/demo.jpg \ + --work-dir work_dir \ + --show \ + --device cpu + --dump-info +``` + +#### TensorRT + +```shell +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py \ + configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py \ + ${PATH_TO_CHECKPOINTS} \ + demo/demo.jpg \ + --work-dir work_dir \ + --show \ + --device cuda:0 + --dump-info +``` + +When convert the model using the above commands, you will find the following files under the `work_dir` folder: + +![image](https://github.com/open-mmlab/mmdeploy/assets/110151316/760f3f7f-aa23-46cf-987c-717d3490246f) + +or + +![image](https://github.com/open-mmlab/mmdeploy/assets/110151316/732bcd9a-fca0-40ba-b5af-540a47eb9c35) + +After exporting to `onnxruntime`, you will get six files as shown in Figure 1, where `end2end.onnx` represents the exported `onnxruntime` model. The `xxx.json` are the meta info for `MMDeploy SDK` inference. + +After exporting to `TensorRT`, you will get the seven files as shown in Figure 2, where `end2end.onnx` represents the exported intermediate model. `MMDeploy` uses this model to automatically continue to convert the `end2end.engine` model for `TensorRT `Deployment. The `xxx.json` are the meta info for `MMDeploy SDK` inference. + +## How to Evaluate Model + +After successfully convert the model, you can use `${MMDEPLOY_DIR}/tools/test.py` to evaluate the converted model. The following part shows how to evaluate the static models of `ONNXRuntime` and `TensorRT`. For dynamic model evaluation, please modify the configuration of the inputs. + +### ONNXRuntime + +```shell +python3 ${MMDEPLOY_DIR}/tools/test.py \ + configs/deploy/detection_onnxruntime_static.py \ + configs/deploy/model/yolov5_s-static.py \ + --model work_dir/end2end.onnx \ + --device cpu \ + --work-dir work_dir +``` + +Once the process is done, you can get the output results as this: + +![image](https://user-images.githubusercontent.com/92794867/199380483-cf8d867b-7309-4994-938a-f743f4cada77.png) + +### TensorRT + +Note: `TensorRT` must run on `CUDA` devices! + +```shell +python3 ${MMDEPLOY_DIR}/tools/test.py \ + configs/deploy/detection_tensorrt_static-640x640.py \ + configs/deploy/model/yolov5_s-static.py \ + --model work_dir/end2end.engine \ + --device cuda:0 \ + --work-dir work_dir +``` + +Once the process is done, you can get the output results as this: + +![image](https://user-images.githubusercontent.com/92794867/199380370-da15cfca-2723-4e5b-b6cf-0afb5f44a66a.png) + +More useful evaluation tools will be released in the future. + +# Deploy using Docker + +`MMYOLO` provides a deployment [`Dockerfile`](https://github.com/open-mmlab/mmyolo/blob/main/docker/Dockerfile_deployment) for deployment purpose. Please make sure your local docker version is greater than `19.03`. + +Note: users in mainland China can comment out the `Optional` part in the dockerfile for better experience. + +```dockerfile +# (Optional) +RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list && \ + pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple +``` + +To build the docker image, + +```bash +# build an image with PyTorch 1.12, CUDA 11.6, TensorRT 8.2.4 ONNXRuntime 1.8.1 +docker build -f docker/Dockerfile_deployment -t mmyolo:v1 . +``` + +To run the docker image, + +```bash +export DATA_DIR=/path/to/your/dataset +docker run --gpus all --shm-size=8g -it --name mmyolo -v ${DATA_DIR}:/openmmlab/mmyolo/data/coco mmyolo:v1 +``` + +`DATA_DIR` is the path of your `COCO` dataset. + +We provide a `script.sh` file for you which runs the whole pipeline. Create the script under `/openmmlab/mmyolo` directory in your docker container using the following content. + +```bash +#!/bin/bash +wget -q https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + -O yolov5s.pth +export MMDEPLOY_DIR=/openmmlab/mmdeploy +export PATH_TO_CHECKPOINTS=/openmmlab/mmyolo/yolov5s.pth + +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + configs/deploy/detection_tensorrt_static-640x640.py \ + configs/deploy/model/yolov5_s-static.py \ + ${PATH_TO_CHECKPOINTS} \ + demo/demo.jpg \ + --work-dir work_dir_trt \ + --device cuda:0 + +python3 ${MMDEPLOY_DIR}/tools/test.py \ + configs/deploy/detection_tensorrt_static-640x640.py \ + configs/deploy/model/yolov5_s-static.py \ + --model work_dir_trt/end2end.engine \ + --device cuda:0 \ + --work-dir work_dir_trt + +python3 ${MMDEPLOY_DIR}/tools/deploy.py \ + configs/deploy/detection_onnxruntime_static.py \ + configs/deploy/model/yolov5_s-static.py \ + ${PATH_TO_CHECKPOINTS} \ + demo/demo.jpg \ + --work-dir work_dir_ort \ + --device cpu + +python3 ${MMDEPLOY_DIR}/tools/test.py \ + configs/deploy/detection_onnxruntime_static.py \ + configs/deploy/model/yolov5_s-static.py \ + --model work_dir_ort/end2end.onnx \ + --device cpu \ + --work-dir work_dir_ort +``` + +Then run the script under `/openmmlab/mmyolo`. + +```bash +sh script.sh +``` + +This script automatically downloads the `YOLOv5` pretrained weights in `MMYOLO` and convert the model using `MMDeploy`. You will get the output result as follows. + +- TensorRT： + + ![image](https://user-images.githubusercontent.com/92794867/199657349-1bad9196-c00b-4a65-84f5-80f51e65a2bd.png) + +- ONNXRuntime： + + ![image](https://user-images.githubusercontent.com/92794867/199657283-95412e84-3ba4-463f-b4b2-4bf52ec4acbd.png) + +We can see from the above images that the accuracy of converted models shrink within 1% compared with the pytorch [MMYOLO-YOLOv5](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5#results-and-models) models. + +If you need to test the inference speed of the converted model, you can use the following commands. + +- TensorRT + +```shell +python3 ${MMDEPLOY_DIR}/tools/profiler.py \ + configs/deploy/detection_tensorrt_static-640x640.py \ + configs/deploy/model/yolov5_s-static.py \ + data/coco/val2017 \ + --model work_dir_trt/end2end.engine \ + --device cuda:0 +``` + +- ONNXRuntime + +```shell +python3 ${MMDEPLOY_DIR}/tools/profiler.py \ + configs/deploy/detection_onnxruntime_static.py \ + configs/deploy/model/yolov5_s-static.py \ + data/coco/val2017 \ + --model work_dir_ort/end2end.onnx \ + --device cpu +``` + +## Model Inference + +### Backend Model Inference + +#### ONNXRuntime + +For the converted model `end2end.onnx`，you can do the inference with the following code： + +```python +from mmdeploy.apis.utils import build_task_processor +from mmdeploy.utils import get_input_shape, load_config +import torch + +deploy_cfg = './configs/deploy/detection_onnxruntime_dynamic.py' +model_cfg = '../mmyolo/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' +device = 'cpu' +backend_model = ['./work_dir/end2end.onnx'] +image = '../mmyolo/demo/demo.jpg' + +# read deploy_cfg and model_cfg +deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg) + +# build task and backend model +task_processor = build_task_processor(model_cfg, deploy_cfg, device) +model = task_processor.build_backend_model(backend_model) + +# process input image +input_shape = get_input_shape(deploy_cfg) +model_inputs, _ = task_processor.create_input(image, input_shape) + +# do model inference +with torch.no_grad(): + result = model.test_step(model_inputs) + +# visualize results +task_processor.visualize( + image=image, + model=model, + result=result[0], + window_name='visualize', + output_file='work_dir/output_detection.png') +``` + +#### TensorRT + +For the converted model `end2end.engine`，you can do the inference with the following code： + +```python +from mmdeploy.apis.utils import build_task_processor +from mmdeploy.utils import get_input_shape, load_config +import torch + +deploy_cfg = './configs/deploy/detection_tensorrt_dynamic-192x192-960x960.py' +model_cfg = '../mmyolo/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' +device = 'cuda:0' +backend_model = ['./work_dir/end2end.engine'] +image = '../mmyolo/demo/demo.jpg' + +# read deploy_cfg and model_cfg +deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg) + +# build task and backend model +task_processor = build_task_processor(model_cfg, deploy_cfg, device) +model = task_processor.build_backend_model(backend_model) + +# process input image +input_shape = get_input_shape(deploy_cfg) +model_inputs, _ = task_processor.create_input(image, input_shape) + +# do model inference +with torch.no_grad(): + result = model.test_step(model_inputs) + +# visualize results +task_processor.visualize( + image=image, + model=model, + result=result[0], + window_name='visualize', + output_file='work_dir/output_detection.png') +``` + +### SDK Model Inference + +#### ONNXRuntime + +For the converted model `end2end.onnx`，you can do the SDK inference with the following code： + +```python +from mmdeploy_runtime import Detector +import cv2 + +img = cv2.imread('../mmyolo/demo/demo.jpg') + +# create a detector +detector = Detector(model_path='work_dir', + device_name='cpu', device_id=0) +# perform inference +bboxes, labels, masks = detector(img) + +# visualize inference result +indices = [i for i in range(len(bboxes))] +for index, bbox, label_id in zip(indices, bboxes, labels): + [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4] + if score < 0.3: + continue + + cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0)) + +cv2.imwrite('work_dir/output_detection.png', img) +``` + +#### TensorRT + +For the converted model `end2end.engine`，you can do the SDK inference with the following code： + +```python +from mmdeploy_runtime import Detector +import cv2 + +img = cv2.imread('../mmyolo/demo/demo.jpg') + +# create a detector +detector = Detector(model_path='work_dir', + device_name='cuda', device_id=0) +# perform inference +bboxes, labels, masks = detector(img) + +# visualize inference result +indices = [i for i in range(len(bboxes))] +for index, bbox, label_id in zip(indices, bboxes, labels): + [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4] + if score < 0.3: + continue + + cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0)) + +cv2.imwrite('work_dir/output_detection.png', img) +``` + +Besides python API, mmdeploy SDK also provides other FFI (Foreign Function Interface), such as C, C++, C#, Java and so on. You can learn their usage from [demos](https://github.com/open-mmlab/mmdeploy/tree/main/demo). diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/labeling_to_deployment_tutorials.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/labeling_to_deployment_tutorials.md new file mode 100644 index 0000000000000000000000000000000000000000..bce5d53f57e6dad4baafc843ad6f86cb19540eb1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/labeling_to_deployment_tutorials.md @@ -0,0 +1,1331 @@ +# Annotation-to-deployment workflow for custom dataset + +In our daily work and study, we often encounter some tasks that need to train custom dataset. There are few scenarios in which open-source datasets can be used as online models, so we need to carry out a series of operations on our custom datasets to ensure that the models can be put into production and serve users. + +```{SeeAlso} +The video of this document has been posted on Bilibili: [A nanny level tutorials for custom datasets from annotationt to deployment](https://www.bilibili.com/video/BV1RG4y137i5) +``` + +```{Note} +All instructions in this document are done on Linux and are fully available on Windows, only slightly different in commands and operations. +``` + +Default that you have completed the installation of MMYOLO, if not installed, please refer to the document [GET STARTED](https://mmyolo.readthedocs.io/en/latest/get_started.html) for installation. + +In this tutorial, we will introduce the whole process from annotating custom dataset to final training, testing and deployment. The overview steps are as below: + +01. Prepare dataset: `tools/misc/download_dataset.py` +02. Use the software of [labelme](https://github.com/wkentaro/labelme) to annotate: `demo/image_demo.py` + labelme +03. Convert the dataset into COCO format: `tools/dataset_converters/labelme2coco.py` +04. Split dataset:`tools/misc/coco_split.py` +05. Creat a config file based on dataset +06. Dataset visualization analysis: `tools/analysis_tools/dataset_analysis.py` +07. Optimize Anchor size: `tools/analysis_tools/optimize_anchors.py` +08. Visualization the data processing part of config: `tools/analysis_tools/browse_dataset.py` +09. Train: `tools/train.py` +10. Inference: `demo/image_demo.py` +11. Deployment + +```{Note} +After obtaining the model weight and the mAP of validation set, users need to deep analyse the bad cases of incorrect predictions in order to optimize model. MMYOLO will add this function in the future. Expect. +``` + +Each step is described in detail below. + +## 1. Prepare custom dataset + +- If you don't have your own dataset, or want to use a small dataset to run the whole process, you can use the 144 images `cat` dataset provided with this tutorial (the raw picture of this dataset is supplied by @RangeKing, cleaned by @PeterH0323). This `cat` dataset will be used as an example for the rest tutorial. + +
+cat dataset +
+ +The download is also very simple, requiring only one command (dataset compression package size `217 MB`): + +```shell +python tools/misc/download_dataset.py --dataset-name cat --save-dir ./data/cat --unzip --delete +``` + +This dataset is automatically downloaded to the `./data/cat` dir with the following directory structure: + +```shell +. +└── ./data/cat + ├── images # image files + │ ├── image1.jpg + │ ├── image2.png + │ └── ... + ├── labels # labelme files + │ ├── image1.json + │ ├── image2.json + │ └── ... + ├── annotations # annotated files of COCO + │ ├── annotations_all.json # all labels of COCO + │ ├── trainval.json # 80% labels of the dataset + │ └── test.json # 20% labels of the dataset + └── class_with_id.txt # id + class_name file +``` + +This dataset can be trained directly. You can remove everything **outside** the `images` dir if you want to go through the whole process. + +- If you already have a dataset, you can compose it into the following structure: + +```shell +. +└── $DATA_ROOT + └── images + ├── image1.jpg + ├── image2.png + └── ... +``` + +## 2. Use the software of labelme to annotate + +In general, there are two annotation methods: + +- Software or algorithmic assistance + manual correction (Recommend, reduce costs and speed up) +- Only manual annotation + +```{Note} +At present, we also consider to access third-party libraries to support the integration of algorithm-assisted annotation and manual optimized annotation by calling MMYOLO inference API through GUI interface. +If you have any interest or ideas, please leave a comment in the issue or contact us directly! +``` + +### 2.1 Software or algorithmic assistance + manual correction + +The principle is using the existing model to inference, and save the result as label file. Manually operating the software and loading the generated label files, you only need to check whether each image is correctly labeled and whether there are missing objects.【assistance + manual correction】you can save a lot of time in order to **reduce costs and speed up** by this way. + +```{Note} +If the existing model doesn't have the categories defined in your dataset, such as COCO pre-trained model, you can manually annotate 100 images to train an initial model, and then software assistance. +``` + +The process is described below: + +#### 2.1.1 Software or algorithmic assistance + +MMYOLO provide model inference script `demo/image_demo.py`. Setting `--to-labelme` to generate labelme format label file: + +```shell +python demo/image_demo.py img \ + config \ + checkpoint + [--out-dir OUT_DIR] \ + [--device DEVICE] \ + [--show] \ + [--deploy] \ + [--score-thr SCORE_THR] \ + [--class-name CLASS_NAME] + [--to-labelme] +``` + +These include: + +- `img`： image path, supported by dir, file, URL; +- `config`：config file path of model; +- `checkpoint`：weight file path of model; +- `--out-dir`：inference results saved in this dir, default as `./output`, if set this `--show` parameter, the detection results are not saved; +- `--device`：cumputing resources, including `CUDA`, `CPU` etc., default as `cuda:0`; +- `--show`：display the detection results, default as `False`； +- `--deploy`：whether to switch to deploy mode; +- `--score-thr`：confidence threshold, default as `0.3`; +- `--to-labelme`：whether to export label files in `labelme` format, shouldn't exist with the `--show` at the same time. + +For example: + +Here, we'll use YOLOv5-s as an example to help us label the 'cat' dataset we just downloaded. First, download the weights for YOLOv5-s: + +```shell +mkdir work_dirs +wget https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth -P ./work_dirs +``` + +Since the COCO 80 dataset already includes the `cat` class, we can directly load the COCO pre-trained model for assistant annotation. + +```shell +python demo/image_demo.py ./data/cat/images \ + ./configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + ./work_dirs/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --out-dir ./data/cat/labels \ + --class-name cat \ + --to-labelme +``` + +```{Tip} +- If your dataset needs to label with multiclass, you can use this `--class-name class1 class2` format; +- Removing the `--class-name` flag to output all classes. +``` + +the generated label files saved in `--out-dir`: + +```shell +. +└── $OUT_DIR + ├── image1.json + ├── image1.json + └── ... +``` + +Here is an example of the original image and it's generating json file: + +
+ Image + Image +
+ +#### 2.1.2 Manual annotation + +In this tutorial, we use [labelme](https://github.com/wkentaro/labelme) to annotate + +- Install labelme + +```shell +conda create -n labelme python=3.8 +conda activate labelme +pip install labelme==5.1.1 +``` + +- Start labelme + +```shell +labelme ${image dir path (same as the previous step)} \ + --output ${the dir path of label file（same as --out-dir）} \ + --autosave \ + --nodata +``` + +These include: + +- `--output`：saved path of labelme file. If there already exists label file of some images, it will be loaded; +- `--autosave`：auto-save label file, and some tedioys steps will be omitted. +- `--nodata`：doesn't store the base64 encoding of each image, so setting this flag will greatly reduce the size of the label file. + +For example： + +```shell +cd /path/to/mmyolo +labelme ./data/cat/images --output ./data/cat/labels --autosave --nodata +``` + +Type in command and labelme will start, and then check label. If labelme fails to start, type `export QT_DEBUG_PLUGINS=1` in command to see which libraries are missing and install it. + +
+label UI +
+ +```{warning} +Make sure to use `rectangle` with the shortcut `Ctrl + R` (see below). + +
+rectangle +
+``` + +### 2.2 Only manual annotation + +The procedure is the same as 【2.1.2 Manual annotation】, except that this is a direct labeling, there is no pre-generated label. + +## 3. Convert the dataset into COCO format + +### 3.1 Using scripts to convert + +MMYOLO provides scripts to convert labelme labels to COCO labels + +```shell +python tools/dataset_converters/labelme2coco.py --img-dir ${image dir path} \ + --labels-dir ${label dir location} \ + --out ${output COCO label json path} \ + [--class-id-txt ${class_with_id.txt path}] +``` + +These include: +`--class-id-txt`: is the `.txt` file of `id class_name` dataset: + +- If not specified, the script will be generated automatically in the same directory as `--out`, and save it as `class_with_id.txt`; + +- If specified, the script will read but not add or overwrite. It will also check if there are any other classes in the `.txt` file and will give you an error if there are any. Please check the `.txt` file and add the new class and its `id`. + +An example `.txt` file looks like this (`id` start at `1`, just like COCO): + +```text +1 cat +2 dog +3 bicycle +4 motorcycle + +``` + +For example: + +Coonsider the `cat` dataset for this tutorial: + +```shell +python tools/dataset_converters/labelme2coco.py --img-dir ./data/cat/images \ + --labels-dir ./data/cat/labels \ + --out ./data/cat/annotations/annotations_all.json +``` + +For the `cat` dataset in this demo (note that we don't need to include the background class), we can see that the generated `class_with_id.txt` has only the `1` class: + +```text +1 cat + +``` + +### 3.2 Check the converted COCO label + +Using the following command, we can display the COCO label on the image, which will verify that there are no problems with the conversion: + +```shell +python tools/analysis_tools/browse_coco_json.py --img-dir ${image dir path} \ + --ann-file ${COCO label json path} +``` + +For example: + +```shell +python tools/analysis_tools/browse_coco_json.py --img-dir ./data/cat/images \ + --ann-file ./data/cat/annotations/annotations_all.json +``` + +
+Image +
+ +```{SeeAlso} +See [Visualizing COCO label](https://mmyolo.readthedocs.io/en/latest/user_guides/useful_tools.html#coco) for more information on `tools/analysis_tools/browse_coco_json.py`. +``` + +## 4. Divide dataset into training set, validation set and test set + +Usually, custom dataset is a large folder with full of images. We need to divide the dataset into training set, validation set and test set by ourselves. If the amount of data is small, we can not divide the validation set. Here's how the split script works: + +```shell +python tools/misc/coco_split.py --json ${COCO label json path} \ + --out-dir ${divide label json saved path} \ + --ratios ${ratio of division} \ + [--shuffle] \ + [--seed ${random seed for division}] +``` + +These include: + +- `--ratios`: ratio of division. If only 2 are set, the split is `trainval + test`, and if 3 are set, the split is `train + val + test`. Two formats are supported - integer and decimal: + + - Integer: divide the dataset in proportion after normalization. Example: `--ratio 2 1 1` (the code will convert to `0.5 0.25 0.25`) or `--ratio 3 1`（the code will convert to `0.75 0.25`） + + - Decimal: divide the dataset in proportion. **If the sum does not add up to 1, the script performs an automatic normalization correction.** Example: `--ratio 0.8 0.1 0.1` or `--ratio 0.8 0.2` + +- `--shuffle`: whether to shuffle the dataset before splitting. + +- `--seed`: the random seed of dataset division. If not set, this will be generated automatically. + +For example: + +```shell +python tools/misc/coco_split.py --json ./data/cat/annotations/annotations_all.json \ + --out-dir ./data/cat/annotations \ + --ratios 0.8 0.2 \ + --shuffle \ + --seed 10 +``` + +
+Image +
+ +## 5. Create a new config file based on the dataset + +Make sure the dataset directory looks like this: + +```shell +. +└── $DATA_ROOT + ├── annotations + │ ├── trainval.json # only divide into trainval + test according to the above commands; If you use 3 groups to divide the ratio, here is train.json、val.json、test.json + │ └── test.json + ├── images + │ ├── image1.jpg + │ ├── image1.png + │ └── ... + └── ... +``` + +Since this is custom dataset, we need to create a new config and add some information we want to change. + +About naming the new config: + +- This config inherits from `yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py`; +- We will train the class `cat` from the dataset provided with this tutorial (if you are using your own dataset, you can define the class name of your own dataset); +- The GPU tested in this tutorial is 1 x 3080Ti with 12G video memory, and the computer memory is 32G. The maximum batch size for YOLOv5-s training is `batch size = 32` (see the Appendix for detailed machine information); +- Training epoch is `100 epoch`. + +To sum up: you can name it `yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py` and place it into the dir of `configs/custom_dataset`. + +Create a new directory named `custom_dataset` inside configs dir, and add config file with the following content: + +
+Image +
+ +```python +_base_ = '../yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py' + +max_epochs = 100 # maximum epochs for training +data_root = './data/cat/' # absolute path to the dataset directory +# data_root = '/root/workspace/mmyolo/data/cat/' # absolute path to the dataset dir inside the Docker container + +# the path of result save, can be omitted, omitted save file name is located under work_dirs with the same name of config file. +# If a config variable changes only part of its parameters, changing this variable will save the new training file elsewhere +work_dir = './work_dirs/yolov5_s-v61_syncbn_fast_1xb32-100e_cat' + +# load_from can specify a local path or URL, setting the URL will automatically download, because the above has been downloaded, we set the local path here +# since this tutorial is fine-tuning on the cat dataset, we need to use `load_from` to load the pre-trained model from MMYOLO. This allows for faster convergence and accuracy +load_from = './work_dirs/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth' # noqa + +# according to your GPU situation, modify the batch size, and YOLOv5-s defaults to 8 cards x 16bs +train_batch_size_per_gpu = 32 +train_num_workers = 4 # recommend to use train_num_workers = nGPU x 4 + +save_epoch_intervals = 2 # save weights every interval round + +# according to your GPU situation, modify the base_lr, modification ratio is base_lr_default * (your_bs / default_bs) +base_lr = _base_.base_lr / 4 + +anchors = [ # the anchor has been updated according to the characteristics of dataset. The generation of anchor will be explained in the following section. + [(68, 69), (154, 91), (143, 162)], # P3/8 + [(242, 160), (189, 287), (391, 207)], # P4/16 + [(353, 337), (539, 341), (443, 432)] # P5/32 +] + +class_name = ('cat', ) # according to the label information of class_with_id.txt, set the class_name +num_classes = len(class_name) +metainfo = dict( + classes=class_name, + palette=[(220, 20, 60)] # the color of drawing, free to set +) + +train_cfg = dict( + max_epochs=max_epochs, + val_begin=20, # number of epochs to start validation. Here 20 is set because the accuracy of the first 20 epochs is not high and the test is not meaningful, so it is skipped + val_interval=save_epoch_intervals # the test evaluation is performed iteratively every val_interval round +) + +model = dict( + bbox_head=dict( + head_module=dict(num_classes=num_classes), + prior_generator=dict(base_sizes=anchors), + + # loss_cls is dynamically adjusted based on num_classes, but when num_classes = 1, loss_cls is always 0 + loss_cls=dict(loss_weight=0.5 * + (num_classes / 80 * 3 / _base_.num_det_layers)))) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + _delete_=True, + type='RepeatDataset', + # if the dataset is too small, you can use RepeatDataset, which repeats the current dataset n times per epoch, where 5 is set. + times=5, + dataset=dict( + type=_base_.dataset_type, + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.train_pipeline))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/trainval.json') +test_evaluator = val_evaluator + +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +default_hooks = dict( + # set how many epochs to save the model, and the maximum number of models to save,`save_best` is also the best model (recommended). + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + max_keep_ckpts=5, + save_best='auto'), + param_scheduler=dict(max_epochs=max_epochs), + # logger output interval + logger=dict(type='LoggerHook', interval=10)) + +``` + +```{Note} +We put an identical config file in `projects/misc/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py`. You can choose to copy to `configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py` to start training directly. +``` + +## 6. Visual analysis of datasets + +The script `tools/analysis_tools/dataset_analysis.py` will helo you get a plot of your dataset. The script can generate four types of analysis graphs: + +- A distribution plot showing categories and the number of bbox instances: `show_bbox_num` +- A distribution plot showing categories and the width and height of bbox instances: `show_bbox_wh` +- A distribution plot showing categories and the width/height ratio of bbox instances: `show_bbox_wh_ratio` +- A distribution plot showing categories and the area of bbox instances based on the area rule: `show_bbox_area` + +Here's how the script works: + +```shell +python tools/analysis_tools/dataset_analysis.py ${CONFIG} \ + [--val-dataset ${TYPE}] \ + [--class-name ${CLASS_NAME}] \ + [--area-rule ${AREA_RULE}] \ + [--func ${FUNC}] \ + [--out-dir ${OUT_DIR}] +``` + +For example: + +Consider the config of `cat` dataset in this tutorial: + +Check the distribution of the training data: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py \ + --out-dir work_dirs/dataset_analysis_cat/train_dataset +``` + +Check the distribution of the validation data: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py \ + --out-dir work_dirs/dataset_analysis_cat/val_dataset \ + --val-dataset +``` + +Effect (click on the image to view a larger image): + + + + + + + + + + + + + + + + + + + + +
+ A distribution plot showing categories and the area of bbox instances based on the area rule + + A distribution plot showing categories and the width and height of bbox instances +
+ YOLOv5CocoDataset_bbox_area + + YOLOv5CocoDataset_bbox_wh +
+ A distribution plot showing categories and the number of bbox instances + + A distribution plot showing categories and the width/height ratio of bbox instances +
+ YOLOv5CocoDataset_bbox_num + + YOLOv5CocoDataset_bbox_ratio +
+ +```{Note} +Due to the cat dataset used in this tutorial is relatively small, we use RepeatDataset in config. The numbers shown are actually repeated five times. If you want a repeat-free analysis, you can change the `times` argument in RepeatDataset from `5` to `1` for now. +``` + +From the analysis output, we can conclude that the training set of the `cat` dataset used in this tutorial has the following characteristics: + +- The images are all `large object`; +- The number of categories cat is `655`; +- The width and height ratio of bbox is mostly concentrated in `1.0 ~ 1.11`, the minimum ratio is `0.36` and the maximum ratio is `2.9`; +- The width of bbox is about `500 ~ 600` , and the height is about `500 ~ 600`. + +```{SeeAlso} +See [Visualizing Dataset Analysis](https://mmyolo.readthedocs.io/en/latest/user_guides/useful_tools.html#id4) for more information on `tools/analysis_tools/dataset_analysis.py` +``` + +## 7. Optimize Anchor size + +```{Warning} +This step only works for anchor-base models such as YOLOv5; + +This step can be skipped for Anchor-free models, such as YOLOv6, YOLOX. +``` + +The `tools/analysis_tools/optimize_anchors.py` script supports three anchor generation methods from YOLO series: `k-means`, `Differential Evolution` and `v5-k-means`. + +In this tutorial, we will use YOLOv5 for training, with an input size of `640 x 640`, and `v5-k-means` to optimize anchor: + +```shell +python tools/analysis_tools/optimize_anchors.py configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py \ + --algorithm v5-k-means \ + --input-shape 640 640 \ + --prior-match-thr 4.0 \ + --out-dir work_dirs/dataset_analysis_cat +``` + +```{Note} +Because this command uses the k-means clustering algorithm, there is some randomness, which is related to the initialization. Therefore, the Anchor obtained by each execution will be somewhat different, but it is generated based on the dataset passed in, so it will not have any adverse effects. +``` + +The calculated anchors are as follows: + +
+Anchor +
+ +Modify the `anchors` variable in config file: + +```python +anchors = [ + [(68, 69), (154, 91), (143, 162)], # P3/8 + [(242, 160), (189, 287), (391, 207)], # P4/16 + [(353, 337), (539, 341), (443, 432)] # P5/32 +] +``` + +```{SeeAlso} +See [Optimize Anchor Sizes](https://mmyolo.readthedocs.io/en/latest/user_guides/useful_tools.html#id8) for more information on `tools/analysis_tools/optimize_anchors.py` +``` + +## 8. Visualization the data processing part of config + +The script `tools/analysis_tools/browse_dataset.py` allows you to visualize the data processing part of config directly in the window, with the option to save the visualization to a specific directory. + +Let's use the config file we just created `configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py` to visualize the images. Each image lasts for `3` seconds, and the images are not saved: + +```shell +python tools/analysis_tools/browse_dataset.py configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py \ + --show-interval 3 +``` + +
+image +
+ +
+image +
+ +```{SeeAlso} +See [Visualizing Datasets](https://mmyolo.readthedocs.io/en/latest/user_guides/useful_tools.html#id3) for more information on `tools/analysis_tools/browse_dataset.py` +``` + +## 9. Train + +Here are three points to explain: + +1. Training visualization +2. YOLOv5 model training +3. Switching YOLO model training + +### 9.1 Training visualization + +If you need to use a browser to visualize the training process, MMYOLO currently offers two ways [wandb](https://wandb.ai/site) and [TensorBoard](https://tensorflow.google.cn/tensorboard). Pick one according to your own situation (we'll expand support for more visualization backends in the future). + +#### 9.1.1 wandb + +Wandb visualization need registered in [website](https://wandb.ai/site), and in the https://wandb.ai/settings for wandb API Keys. + +
+image +
+ +Then install it from the command line: + +```shell +pip install wandb +# After running wandb login, enter the API Keys obtained above, and the login is successful. +wandb login +``` + +
+Image +
+ +Add the `wandb` configuration at the end of config file we just created, `configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py`. + +```python +visualizer = dict(vis_backends=[dict(type='LocalVisBackend'), dict(type='WandbVisBackend')]) +``` + +#### 9.1.2 TensorBoard + +Install Tensorboard environment + +```shell +pip install tensorboard +``` + +Add the `tensorboard` configuration at the end of config file we just created, `configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py`. + +```python +visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')]) +``` + +After running the training command, Tensorboard files will be generated in the visualization folder `work_dirs/yolov5_s-v61_syncbn_fast_1xb32-100e_cat/${TIMESTAMP}/vis_data`. We can use Tensorboard to view the loss, learning rate, and coco/bbox_mAP visualizations from a web link by running the following command: + +```shell +tensorboard --logdir=work_dirs/yolov5_s-v61_syncbn_fast_1xb32-100e_cat +``` + +### 9.2 Perform training + +Let's start the training with the following command (training takes about 2.5 hours) : + +```shell +python tools/train.py configs/custom_dataset/yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py +``` + +If you have enabled wandb, you can log in to your account to view the details of this training in wandb: + +
+Image +
+ +
+Image +
+ +The following is `1 x 3080Ti`, `batch size = 32`, training `100 epoch` optimal precision weight `work_dirs/yolov5_s-v61_syncbn_fast_1xb32-100e_cat/best_coco/bbox_mAP_epoch_98.pth` obtained accuracy (see Appendix for detailed machine information): + +```shell + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.968 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.968 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.886 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.977 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.977 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.977 + +bbox_mAP_copypaste: 0.968 1.000 1.000 -1.000 -1.000 0.968 +Epoch(val) [98][116/116] coco/bbox_mAP: 0.9680 coco/bbox_mAP_50: 1.0000 coco/bbox_mAP_75: 1.0000 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.9680 +``` + +```{Tip} +In general finetune best practice, it is recommended that backbone be left out of training and that the learning rate lr be scaled accordingly. However, in this tutorial, we found this approach can fall short to some extent. The possible reason is that the cat category is already in the COCO dataset, and the cat dataset used in this tutorial is relatively small +``` + +The following table shows the test accuracy of the MMYOLO YOLOv5 pre-trained model `yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth` without finetune on the cat dataset. It can be seen that the mAP of the `cat` category is only `0.866`, which improve to `0.968` after finetune, improved by '10.2%', which proves that the training was very successful: + +```shell ++---------------+-------+--------------+-----+----------------+------+ +| category | AP | category | AP | category | AP | ++---------------+-------+--------------+-----+----------------+------+ +| person | nan | bicycle | nan | car | nan | +| motorcycle | nan | airplane | nan | bus | nan | +| train | nan | truck | nan | boat | nan | +| traffic light | nan | fire hydrant | nan | stop sign | nan | +| parking meter | nan | bench | nan | bird | nan | +| cat | 0.866 | dog | nan | horse | nan | +| sheep | nan | cow | nan | elephant | nan | +| bear | nan | zebra | nan | giraffe | nan | +| backpack | nan | umbrella | nan | handbag | nan | +| tie | nan | suitcase | nan | frisbee | nan | +| skis | nan | snowboard | nan | sports ball | nan | +| kite | nan | baseball bat | nan | baseball glove | nan | +| skateboard | nan | surfboard | nan | tennis racket | nan | +| bottle | nan | wine glass | nan | cup | nan | +| fork | nan | knife | nan | spoon | nan | +| bowl | nan | banana | nan | apple | nan | +| sandwich | nan | orange | nan | broccoli | nan | +| carrot | nan | hot dog | nan | pizza | nan | +| donut | nan | cake | nan | chair | nan | +| couch | nan | potted plant | nan | bed | nan | +| dining table | nan | toilet | nan | tv | nan | +| laptop | nan | mouse | nan | remote | nan | +| keyboard | nan | cell phone | nan | microwave | nan | +| oven | nan | toaster | nan | sink | nan | +| refrigerator | nan | book | nan | clock | nan | +| vase | nan | scissors | nan | teddy bear | nan | +| hair drier | nan | toothbrush | nan | None | None | ++---------------+-------+--------------+-----+----------------+------+ +``` + +```{SeeAlso} +For details on how to get the accuracy of the pre-trained weights, see the appendix【2. How to test the accuracy of dataset on pre-trained weights】 +``` + +### 9.3 Switch other models in MMYOLO + +MMYOLO integrates multiple YOLO algorithms, which makes switching between YOLO models very easy. There is no need to reacquaint with a new repo. You can easily switch between YOLO models by simply modifying the config file: + +1. Create a new config file +2. Download the pre-trained weights +3. Starting training + +Let's take YOLOv6-s as an example. + +1. Create a new config file： + +```python +_base_ = '../yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco.py' + +max_epochs = 100 # maximum of training epoch +data_root = './data/cat/' # absolute path to the dataset directory + +# the path of result save, can be omitted, omitted save file name is located under work_dirs with the same name of config file. +# If a config variable changes only part of its parameters, changing this variable will save the new training file elsewhere +work_dir = './work_dirs/yolov6_s_syncbn_fast_1xb32-100e_cat' + +# load_from can specify a local path or URL, setting the URL will automatically download, because the above has been downloaded, we set the local path here +# since this tutorial is fine-tuning on the cat dataset, we need to use `load_from` to load the pre-trained model from MMYOLO. This allows for faster convergence and accuracy +load_from = './work_dirs/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035-932e1d91.pth' # noqa + +# according to your GPU situation, modify the batch size, and YOLOv6-s defaults to 8 cards x 32bs +train_batch_size_per_gpu = 32 +train_num_workers = 4 # recommend to use train_num_workers = nGPU x 4 + +save_epoch_intervals = 2 # save weights every interval round + +# according to your GPU situation, modify the base_lr, modification ratio is base_lr_default * (your_bs / default_bs) +base_lr = _base_.base_lr / 8 + +class_name = ('cat', ) # according to the label information of class_with_id.txt, set the class_name +num_classes = len(class_name) +metainfo = dict( + classes=class_name, + palette=[(220, 20, 60)] # the color of drawing, free to set +) + +train_cfg = dict( + max_epochs=max_epochs, + val_begin=20, # number of epochs to start validation. Here 20 is set because the accuracy of the first 20 epochs is not high and the test is not meaningful, so it is skipped + val_interval=save_epoch_intervals, # the test evaluation is performed iteratively every val_interval round + dynamic_intervals=[(max_epochs - _base_.num_last_epochs, 1)] +) + +model = dict( + bbox_head=dict( + head_module=dict(num_classes=num_classes)), + train_cfg=dict( + initial_assigner=dict(num_classes=num_classes), + assigner=dict(num_classes=num_classes)) +) + +train_dataloader = dict( + batch_size=train_batch_size_per_gpu, + num_workers=train_num_workers, + dataset=dict( + _delete_=True, + type='RepeatDataset', + # if the dataset is too small, you can use RepeatDataset, which repeats the current dataset n times per epoch, where 5 is set. + times=5, + dataset=dict( + type=_base_.dataset_type, + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=_base_.train_pipeline))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/trainval.json') +test_evaluator = val_evaluator + +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +default_hooks = dict( + # set how many epochs to save the model, and the maximum number of models to save,`save_best` is also the best model (recommended). + checkpoint=dict( + type='CheckpointHook', + interval=save_epoch_intervals, + max_keep_ckpts=5, + save_best='auto'), + param_scheduler=dict(max_epochs=max_epochs), + # logger output interval + logger=dict(type='LoggerHook', interval=10)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + strict_load=False, + priority=49), + dict( + type='mmdet.PipelineSwitchHook', + switch_epoch=max_epochs - _base_.num_last_epochs, + switch_pipeline=_base_.train_pipeline_stage2) +] + +``` + +```{Note} +Similarly, We put an identical config file in `projects/misc/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py`. You can choose to copy to `configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py` to start training directly. + +Even though the new config looks like a lot of stuff, it's actually a lot of duplication. You can use a comparison software to see that most of the configuration is identical to 'yolov5_s-v61_syncbn_fast_1xb32-100e_cat.py'. Because the two config files need to inherit from different config files, you still need to add the necessary configuration. +``` + +2. Download the pre-trained weights + +```bash +wget https://download.openmmlab.com/mmyolo/v0/yolov6/yolov6_s_syncbn_fast_8xb32-400e_coco/yolov6_s_syncbn_fast_8xb32-400e_coco_20221102_203035-932e1d91.pth -P work_dirs/ +``` + +3. Starting training + +```shell +python tools/train.py configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py +``` + +In my experiments, the best model is `work_dirs/yolov6_s_syncbn_fast_1xb32-100e_cat/best_coco/bbox_mAP_epoch_96.pth`,which accuracy is as follows: + +```bash + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.987 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.987 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.895 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.989 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.989 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.989 + +bbox_mAP_copypaste: 0.987 1.000 1.000 -1.000 -1.000 0.987 +Epoch(val) [96][116/116] coco/bbox_mAP: 0.9870 coco/bbox_mAP_50: 1.0000 coco/bbox_mAP_75: 1.0000 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.9870 +``` + +The above demonstrates how to switch models in MMYOLO, you can quickly compare the accuracy of different models, and the model with high accuracy can be put into production. In my experiment, the best accuracy of YOLOv6 `0.9870` is `1.9 %` higher than the best accuracy of YOLOv5 `0.9680` , so we will use YOLOv6 for explanation. + +## 10. Inference + +Using the best model for inference, the best model path in the following command is `./work_dirs/yolov6_s_syncbn_fast_1xb32-100e_cat/best_coco/bbox_mAP_epoch_96.pth`, please modify the best model path you trained. + +```shell +python demo/image_demo.py ./data/cat/images \ + ./configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py \ + ./work_dirs/yolov6_s_syncbn_fast_1xb32-100e_cat/best_coco/bbox_mAP_epoch_96.pth \ + --out-dir ./data/cat/pred_images +``` + +
+Image +
+ +```{Tip} +If the inference result is not ideal, here are two cases: + +1. Model underfitting: + + First, we need to determine if there is not enough training epochs resulting in underfitting. If there is not enough training, we need to change the `max_epochs` and `work_dir` parameters in the config file, or create a new config file named as above and start the training again. + +2. The dataset needs to be optimized: + If adding epochs still doesn't work, we can increase the number of datasets and re-examine and refine the annotations of the dataset before retraining. +``` + +## 11. Deployment + +MMYOLO provides two deployment options: + +1. [MMDeploy](https://github.com/open-mmlab/mmdeploy) framework for deployment +2. Using `projects/easydeploy` to deployment + +### 11.1 MMDeploy framework for deployment + +Considering that the wide variety of machine deployments, there are many times when a local machine will work, but not in production. Here, we recommended to use Docker, so that the environment can be deployed once and used for life, saving the time of operation and maintenance to build the environment and deploy production. + +In this part, we will introduce the following steps: + +1. Building a Docker image +2. Creating a Docker container +3. Transforming TensorRT models +4. Deploying model and performing inference + +```{SeeAlso} +If you are not familiar with Docker, you can refer to the MMDeploy [source manual installation].(https://mmdeploy.readthedocs.io/en/latest/01-how-to-build/build_from_source.html) file to compile directly locally. Once installed, you can skip to【11.1.3 Transforming TensorRT models】 +``` + +#### 11.1.1 Building a Docker image + +```shell +git clone -b dev-1.x https://github.com/open-mmlab/mmdeploy.git +cd mmdeploy +docker build docker/GPU/ -t mmdeploy:gpu --build-arg USE_SRC_INSIDE=true +``` + +Where `USE_SRC_INSIDE=true` is to pull the basis after switching the domestic source, the build speed will be faster. + +After executing the script, the build will start, which will take a while: + +
+Image +
+ +#### 11.1.2 Creating a Docker container + +```shell +export MMYOLO_PATH=/path/to/local/mmyolo # write the path to MMYOLO on your machine to an environment variable +docker run --gpus all --name mmyolo-deploy -v ${MMYOLO_PATH}:/root/workspace/mmyolo -it mmdeploy:gpu /bin/bash +``` + +
+Image +
+ +You can see your local MMYOLO environment mounted inside the container + +
+Image +
+ +```{SeeAlso} +You can read more about this in the MMDeploy official documentation [Using Docker Images](https://mmdeploy.readthedocs.io/en/latest/01-how-to-build/build_from_docker.html#docker) +``` + +#### 11.1.3 Transforming TensorRT models + +The first step is to install MMYOLO and `pycuda` in a Docker container： + +```shell +export MMYOLO_PATH=/root/workspace/mmyolo # path in the image, which doesn't need to modify +cd ${MMYOLO_PATH} +export MMYOLO_VERSION=$(python -c "import mmyolo.version as v; print(v.__version__)") # Check the version number of MMYOLO used for training +echo "Using MMYOLO ${MMYOLO_VERSION}" +mim install --no-cache-dir mmyolo==${MMYOLO_VERSION} +pip install --no-cache-dir pycuda==2022.2 +``` + +Performing model transformations + +```shell +cd /root/workspace/mmdeploy +python ./tools/deploy.py \ + ${MMYOLO_PATH}/configs/deploy/detection_tensorrt-fp16_dynamic-192x192-960x960.py \ + ${MMYOLO_PATH}/configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py \ + ${MMYOLO_PATH}/work_dirs/yolov6_s_syncbn_fast_1xb32-100e_cat/best_coco/bbox_mAP_epoch_96.pth \ + ${MMYOLO_PATH}/data/cat/images/mmexport1633684751291.jpg \ + --test-img ${MMYOLO_PATH}/data/cat/images/mmexport1633684751291.jpg \ + --work-dir ./work_dir/yolov6_s_syncbn_fast_1xb32-100e_cat_deploy_dynamic_fp16 \ + --device cuda:0 \ + --log-level INFO \ + --show \ + --dump-info +``` + +
+Image +
+ +Wait for a few minutes, `All process success.` appearance indicates success: + +
+Image +
+ +Looking at the exported path, you can see the file structure as shown in the following screenshot: + +```shell +$WORK_DIR + ├── deploy.json + ├── detail.json + ├── end2end.engine + ├── end2end.onnx + └── pipeline.json +``` + +```{SeeAlso} +For a detailed description of transforming models, see [How to Transform Models](https://mmdeploy.readthedocs.io/en/latest/02-how-to-run/convert_model.html) +``` + +#### 11.1.4 Deploying model and performing inference + +We need to change the `data_root` in `${MMYOLO_PATH}/configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py` to the path in the Docker container: + +```python +data_root = '/root/workspace/mmyolo/data/cat/' # absolute path of the dataset dir in the Docker container. +``` + +Execute speed and accuracy tests: + +```shell +python tools/test.py \ + ${MMYOLO_PATH}/configs/deploy/detection_tensorrt-fp16_dynamic-192x192-960x960.py \ + ${MMYOLO_PATH}/configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py \ + --model ./work_dir/yolov6_s_syncbn_fast_1xb32-100e_cat_deploy_dynamic_fp16/end2end.engine \ + --speed-test \ + --device cuda +``` + +The speed test is as follows, we can see that the average inference speed is `24.10ms`, which is a speed improvement compared to PyTorch inference, but also reduce lots of video memory usage: + +```shell +Epoch(test) [ 10/116] eta: 0:00:20 time: 0.1919 data_time: 0.1330 memory: 12 +Epoch(test) [ 20/116] eta: 0:00:15 time: 0.1220 data_time: 0.0939 memory: 12 +Epoch(test) [ 30/116] eta: 0:00:12 time: 0.1168 data_time: 0.0850 memory: 12 +Epoch(test) [ 40/116] eta: 0:00:10 time: 0.1241 data_time: 0.0940 memory: 12 +Epoch(test) [ 50/116] eta: 0:00:08 time: 0.0974 data_time: 0.0696 memory: 12 +Epoch(test) [ 60/116] eta: 0:00:06 time: 0.0865 data_time: 0.0547 memory: 16 +Epoch(test) [ 70/116] eta: 0:00:05 time: 0.1521 data_time: 0.1226 memory: 16 +Epoch(test) [ 80/116] eta: 0:00:04 time: 0.1364 data_time: 0.1056 memory: 12 +Epoch(test) [ 90/116] eta: 0:00:03 time: 0.0923 data_time: 0.0627 memory: 12 +Epoch(test) [100/116] eta: 0:00:01 time: 0.0844 data_time: 0.0583 memory: 12 +[tensorrt]-110 times per count: 24.10 ms, 41.50 FPS +Epoch(test) [110/116] eta: 0:00:00 time: 0.1085 data_time: 0.0832 memory: 12 +``` + +Accuracy test is as follows. This configuration uses FP16 format inference, which has some drop points, but it is faster and uses less video memory: + +```shell + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.954 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.975 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.954 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.860 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.965 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.965 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.965 + +INFO - bbox_mAP_copypaste: 0.954 1.000 0.975 -1.000 -1.000 0.954 +INFO - Epoch(test) [116/116] coco/bbox_mAP: 0.9540 coco/bbox_mAP_50: 1.0000 coco/bbox_mAP_75: 0.9750 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.9540 +``` + +Deployment model and inference demonstration: + +```{Note} +You can use the MMDeploy SDK for deployment and use C++ to further improve inference speed. +``` + +```shell +cd ${MMYOLO_PATH}/demo +python deploy_demo.py \ + ${MMYOLO_PATH}/data/cat/images/mmexport1633684900217.jpg \ + ${MMYOLO_PATH}/configs/custom_dataset/yolov6_s_syncbn_fast_1xb32-100e_cat.py \ + /root/workspace/mmdeploy/work_dir/yolov6_s_syncbn_fast_1xb32-100e_cat_deploy_dynamic_fp16/end2end.engine \ + --deploy-cfg ${MMYOLO_PATH}/configs/deploy/detection_tensorrt-fp16_dynamic-192x192-960x960.py \ + --out-dir ${MMYOLO_PATH}/work_dirs/deploy_predict_out \ + --device cuda:0 \ + --score-thr 0.5 +``` + +```{Warning} +The script `deploy_demo.py` doesn't achieve batch inference, and the pre-processing code needs to be improved. It cannot fully show the inference speed at the moment, only demonstrate the inference results. we will optimize in the future. Expect! +``` + +After executing, you can see the inference image results in `--out-dir` : + +
+Image +
+ +```{Note} +You can also use other optimizations like increasing batch size, int8 quantization, etc. +``` + +#### 11.1.5 Save and load the Docker container + +It would be a waste of time to build a docker image every time. At this point you can consider using docker's packaging api for packaging and loading. + +```shell +# save, the result tar package can be placed on mobile hard disk +docker save mmyolo-deploy > mmyolo-deploy.tar + +# load image to system +docker load < /path/to/mmyolo-deploy.tar +``` + +### 11.2 Using `projects/easydeploy` to deploy + +```{SeeAlso} +See [deployment documentation](https://github.com/open-mmlab/mmyolo/blob/dev/projects/easydeploy/README.md) for details. +``` + +TODO: This part will be improved in the next version... + +## Appendix + +### 1. The detailed environment for training the machine in this tutorial is as follows: + +```shell +sys.platform: linux +Python: 3.9.13 | packaged by conda-forge | (main, May 27 2022, 16:58:50) [GCC 10.3.0] +CUDA available: True +numpy_random_seed: 2147483648 +GPU 0: NVIDIA GeForce RTX 3080 Ti +CUDA_HOME: /usr/local/cuda +NVCC: Cuda compilation tools, release 11.5, V11.5.119 +GCC: gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0 +PyTorch: 1.10.0 +PyTorch compiling details: PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) oneAPI Math Kernel Library Version 2021.4-Product Build 20210904 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v2.2.3 (Git Hash 7336ca9f055cf1bfa13efb658fe15dc9b41f0740) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - LAPACK is enabled (usually provided by MKL) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 11.3 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode; + arch=compute_60,code=sm_60;-gencode;arch=compute_61,code=sm_61;-gencode;arch=compute_70,code=sm_70; + -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode; + arch=compute_86,code=sm_86;-gencode;arch=compute_37,code=compute_37 + - CuDNN 8.2 + - Magma 2.5.2 + - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.3, CUDNN_VERSION=8.2.0, + CXX_COMPILER=/opt/rh/devtoolset-7/root/usr/bin/c++, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden + -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_KINETO -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK + -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -DEDGE_PROFILER_USE_KINETO -O2 -fPIC -Wno-narrowing -Wall -Wextra + -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas + -Wno-sign-compare -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic + -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new + -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format + -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, + TORCH_VERSION=1.10.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, + USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +TorchVision: 0.11.0 +OpenCV: 4.6.0 +MMEngine: 0.3.1 +MMCV: 2.0.0rc3 +MMDetection: 3.0.0rc3 +MMYOLO: 0.2.0+cf279a5 +``` + +### 2. How to test the accuracy of our dataset on the pre-trained weights: + +```{Warning} +Premise: The class is in the COCO 80 class! +``` + +In this part, we will use the `cat` dataset as an example, using: + +- config file: `configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py` +- weight `yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth` + +1. modify the path in config file + +Because `configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py` is inherited from `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py`. Therefore, you can mainly modify the `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py` file. + +| before modification | after modification | +| ------------------------------------------------------------------------------ | --------------------------------------------------------------------------- | +| `data_root = 'data/coco/'` | `data_root = './data/cat/'` | +| `ann_file='annotations/instances_train2017.json'` | `ann_file='annotations/trainval.json'` | +| data_prefix=dict(img='train2017/')\` | `data_prefix=dict(img='images/')` | +| `val_evaluator` of `ann_file=data_root + 'annotations/instances_val2017.json'` | `val_evaluator` of `dict(ann_file=data_root + 'annotations/trainval.json')` | + +2. modify label + +```{note} +It is recommended to make a copy of the label directly to prevent damage to original label +``` + +Change the `categories` in `trainval.json` to COCO's original: + +```json + "categories": [{"supercategory": "person","id": 1,"name": "person"},{"supercategory": "vehicle","id": 2,"name": "bicycle"},{"supercategory": "vehicle","id": 3,"name": "car"},{"supercategory": "vehicle","id": 4,"name": "motorcycle"},{"supercategory": "vehicle","id": 5,"name": "airplane"},{"supercategory": "vehicle","id": 6,"name": "bus"},{"supercategory": "vehicle","id": 7,"name": "train"},{"supercategory": "vehicle","id": 8,"name": "truck"},{"supercategory": "vehicle","id": 9,"name": "boat"},{"supercategory": "outdoor","id": 10,"name": "traffic light"},{"supercategory": "outdoor","id": 11,"name": "fire hydrant"},{"supercategory": "outdoor","id": 13,"name": "stop sign"},{"supercategory": "outdoor","id": 14,"name": "parking meter"},{"supercategory": "outdoor","id": 15,"name": "bench"},{"supercategory": "animal","id": 16,"name": "bird"},{"supercategory": "animal","id": 17,"name": "cat"},{"supercategory": "animal","id": 18,"name": "dog"},{"supercategory": "animal","id": 19,"name": "horse"},{"supercategory": "animal","id": 20,"name": "sheep"},{"supercategory": "animal","id": 21,"name": "cow"},{"supercategory": "animal","id": 22,"name": "elephant"},{"supercategory": "animal","id": 23,"name": "bear"},{"supercategory": "animal","id": 24,"name": "zebra"},{"supercategory": "animal","id": 25,"name": "giraffe"},{"supercategory": "accessory","id": 27,"name": "backpack"},{"supercategory": "accessory","id": 28,"name": "umbrella"},{"supercategory": "accessory","id": 31,"name": "handbag"},{"supercategory": "accessory","id": 32,"name": "tie"},{"supercategory": "accessory","id": 33,"name": "suitcase"},{"supercategory": "sports","id": 34,"name": "frisbee"},{"supercategory": "sports","id": 35,"name": "skis"},{"supercategory": "sports","id": 36,"name": "snowboard"},{"supercategory": "sports","id": 37,"name": "sports ball"},{"supercategory": "sports","id": 38,"name": "kite"},{"supercategory": "sports","id": 39,"name": "baseball bat"},{"supercategory": "sports","id": 40,"name": "baseball glove"},{"supercategory": "sports","id": 41,"name": "skateboard"},{"supercategory": "sports","id": 42,"name": "surfboard"},{"supercategory": "sports","id": 43,"name": "tennis racket"},{"supercategory": "kitchen","id": 44,"name": "bottle"},{"supercategory": "kitchen","id": 46,"name": "wine glass"},{"supercategory": "kitchen","id": 47,"name": "cup"},{"supercategory": "kitchen","id": 48,"name": "fork"},{"supercategory": "kitchen","id": 49,"name": "knife"},{"supercategory": "kitchen","id": 50,"name": "spoon"},{"supercategory": "kitchen","id": 51,"name": "bowl"},{"supercategory": "food","id": 52,"name": "banana"},{"supercategory": "food","id": 53,"name": "apple"},{"supercategory": "food","id": 54,"name": "sandwich"},{"supercategory": "food","id": 55,"name": "orange"},{"supercategory": "food","id": 56,"name": "broccoli"},{"supercategory": "food","id": 57,"name": "carrot"},{"supercategory": "food","id": 58,"name": "hot dog"},{"supercategory": "food","id": 59,"name": "pizza"},{"supercategory": "food","id": 60,"name": "donut"},{"supercategory": "food","id": 61,"name": "cake"},{"supercategory": "furniture","id": 62,"name": "chair"},{"supercategory": "furniture","id": 63,"name": "couch"},{"supercategory": "furniture","id": 64,"name": "potted plant"},{"supercategory": "furniture","id": 65,"name": "bed"},{"supercategory": "furniture","id": 67,"name": "dining table"},{"supercategory": "furniture","id": 70,"name": "toilet"},{"supercategory": "electronic","id": 72,"name": "tv"},{"supercategory": "electronic","id": 73,"name": "laptop"},{"supercategory": "electronic","id": 74,"name": "mouse"},{"supercategory": "electronic","id": 75,"name": "remote"},{"supercategory": "electronic","id": 76,"name": "keyboard"},{"supercategory": "electronic","id": 77,"name": "cell phone"},{"supercategory": "appliance","id": 78,"name": "microwave"},{"supercategory": "appliance","id": 79,"name": "oven"},{"supercategory": "appliance","id": 80,"name": "toaster"},{"supercategory": "appliance","id": 81,"name": "sink"},{"supercategory": "appliance","id": 82,"name": "refrigerator"},{"supercategory": "indoor","id": 84,"name": "book"},{"supercategory": "indoor","id": 85,"name": "clock"},{"supercategory": "indoor","id": 86,"name": "vase"},{"supercategory": "indoor","id": 87,"name": "scissors"},{"supercategory": "indoor","id": 88,"name": "teddy bear"},{"supercategory": "indoor","id": 89,"name": "hair drier"},{"supercategory": "indoor","id": 90,"name": "toothbrush"}], +``` + +Also, change the `category_id` in the `annotations` to the `id` corresponding to COCO, for example, `cat` is `17` in this example. Here are some of the results: + +```json + "annotations": [ + { + "iscrowd": 0, + "category_id": 17, # This "category_id" is changed to the id corresponding to COCO, for example, cat is 17 + "id": 32, + "image_id": 32, + "bbox": [ + 822.49072265625, + 958.3897094726562, + 1513.693115234375, + 988.3231811523438 + ], + "area": 1496017.9949368387, + "segmentation": [ + [ + 822.49072265625, + 958.3897094726562, + 822.49072265625, + 1946.712890625, + 2336.183837890625, + 1946.712890625, + 2336.183837890625, + 958.3897094726562 + ] + ] + } + ] +``` + +3. executive command + +```shell +python tools\test.py configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + work_dirs/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --cfg-options test_evaluator.classwise=True +``` + +After executing it, we can see the test metrics: + +```shell ++---------------+-------+--------------+-----+----------------+------+ +| category | AP | category | AP | category | AP | ++---------------+-------+--------------+-----+----------------+------+ +| person | nan | bicycle | nan | car | nan | +| motorcycle | nan | airplane | nan | bus | nan | +| train | nan | truck | nan | boat | nan | +| traffic light | nan | fire hydrant | nan | stop sign | nan | +| parking meter | nan | bench | nan | bird | nan | +| cat | 0.866 | dog | nan | horse | nan | +| sheep | nan | cow | nan | elephant | nan | +| bear | nan | zebra | nan | giraffe | nan | +| backpack | nan | umbrella | nan | handbag | nan | +| tie | nan | suitcase | nan | frisbee | nan | +| skis | nan | snowboard | nan | sports ball | nan | +| kite | nan | baseball bat | nan | baseball glove | nan | +| skateboard | nan | surfboard | nan | tennis racket | nan | +| bottle | nan | wine glass | nan | cup | nan | +| fork | nan | knife | nan | spoon | nan | +| bowl | nan | banana | nan | apple | nan | +| sandwich | nan | orange | nan | broccoli | nan | +| carrot | nan | hot dog | nan | pizza | nan | +| donut | nan | cake | nan | chair | nan | +| couch | nan | potted plant | nan | bed | nan | +| dining table | nan | toilet | nan | tv | nan | +| laptop | nan | mouse | nan | remote | nan | +| keyboard | nan | cell phone | nan | microwave | nan | +| oven | nan | toaster | nan | sink | nan | +| refrigerator | nan | book | nan | clock | nan | +| vase | nan | scissors | nan | teddy bear | nan | +| hair drier | nan | toothbrush | nan | None | None | ++---------------+-------+--------------+-----+----------------+------+ +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/mm_basics.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/mm_basics.md new file mode 100644 index 0000000000000000000000000000000000000000..9f23cfe6606a6a7adfa20b2e532c8f804820ce12 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/mm_basics.md @@ -0,0 +1 @@ +# MM series repo essential basics diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/model_design.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/model_design.md new file mode 100644 index 0000000000000000000000000000000000000000..e1fc5b822abb9b033f582ea2df5c70d3fd708b95 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/model_design.md @@ -0,0 +1,106 @@ +# Model design instructions + +## YOLO series model basic class + +The structural figure is provided by RangeKing@GitHub. Thank you RangeKing！ + +
+BaseModule-P5 +Figure 1: P5 model structure +
+ +
+BaseModule-P6 +Figure 2: P6 model structure +
+ +Most YOLO series algorithms adopt a unified algorithm-building structure, typically as Darknet + PAFPN. In order to let users quickly understand the YOLO series algorithm architecture, we deliberately designed the `BaseBackbone` + `BaseYOLONeck` structure, as shown in the above figure. + +The benefits of the abstract `BaseBackbone` include: + +1. Subclasses do not need to be concerned about the forward process. Just build the model as a builder pattern. +2. It can be configured to achieve custom plug-in functions. Users can easily insert some similar attention modules. +3. All subclasses automatically support freezing certain stages and bn functions. + +`BaseYOLONeck` has the same benefits as `BaseBackbone`. + +### BaseBackbone + +- As shown in Figure 1, for P5, `BaseBackbone` includes 1 stem layer and 4 stage layers which are similar to the basic structure of ResNet. +- As shown in Figure 2, for P6, `BaseBackbone` includes 1 stem layer and 5 stage layers. + Different backbone network algorithms inherit the `BaseBackbone`. Users can build each layer of the whole network by implementing customized basic modules through the internal `build_xx` method. + +### BaseYOLONeck + +We reproduce the YOLO series Neck components in the similar way as the `BaseBackbone`, and we can mainly divide them into `Reduce layer`, `UpSample layer`, `TopDown layer`, `DownSample layer`, `BottomUP layer` and `output convolution layer`. Each layer can be customized its internal construction by the inheritance and rewrite from the `build_xx` method. + +### BaseDenseHead + +MMYOLO uses the `BaseDenseHead` designed in MMDetection as the base class of the Head structure. Take YOLOv5 as an example, the forward function of its [HeadModule](https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/models/dense_heads/yolov5_head.py#L2) replaces the original forward method. + +## HeadModule + +
+image +
+ +As shown in the above graph, the solid line is the implementation in [MMYOLO](https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/models/dense_heads/yolov5_head.py), whereas the original implementation in [MMDetection](https://github.com/open-mmlab/mmdetection) is shown in the dotted line. MMYOLO has the following advantages over the original implementation: + +1. In MMDetection, `bbox_head` is split into three large components: `assigner` + `box coder` + `sampler`. But because the transfer between these three components is universal, it is necessary to encapsulate additional objects. With the unification in MMYOLO, users do not need to separate them. The advantages of not deliberately forcing the division of the three components are: data encapsulation of internal data is no longer required, code logic is simplified, and the difficulty of community use and algorithm reproduction is reduced. +2. MMYOLO is Faster. When users customize the implementation algorithm, they can deeply optimize part of the code without relying on the original framework. + +In general, with the partly decoupled model + `loss_by_feat` part in MMYOLO, users can construct any model with any `loss_by_feat` by modifying the configuration. For example, applying the `loss_by_feat` of YOLOX to the YOLOv5 model, etc. + +Take the YOLOX configuration in MMDetection as an example, the Head module configuration is written as follows: + +```python +bbox_head=dict( + type='YOLOXHead', + num_classes=80, + in_channels=128, + feat_channels=128, + stacked_convs=2, + strides=(8, 16, 32), + use_depthwise=False, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='Swish'), + ... + loss_obj=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + reduction='sum', + loss_weight=1.0), + loss_l1=dict(type='L1Loss', reduction='sum', loss_weight=1.0)), +train_cfg=dict(assigner=dict(type='SimOTAAssigner', center_radius=2.5)), +``` + +For the head_module in MMYOLO, the new configuration is written as follows: + +```python +bbox_head=dict( + type='YOLOXHead', + head_module=dict( + type='YOLOXHeadModule', + num_classes=80, + in_channels=256, + feat_channels=256, + widen_factor=widen_factor, + stacked_convs=2, + featmap_strides=(8, 16, 32), + use_depthwise=False, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='SiLU', inplace=True), + ), + ... + loss_obj=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='sum', + loss_weight=1.0), + loss_bbox_aux=dict(type='mmdet.L1Loss', reduction='sum', loss_weight=1.0)), +train_cfg=dict( + assigner=dict( + type='mmdet.SimOTAAssigner', + center_radius=2.5, + iou_calculator=dict(type='mmdet.BboxOverlaps2D'))), +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/replace_backbone.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/replace_backbone.md new file mode 100644 index 0000000000000000000000000000000000000000..82d2046b8e8906a2d186d1ccffd775ab0f23f3ad --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/replace_backbone.md @@ -0,0 +1,306 @@ +# Replace the backbone network + +```{note} +1. When using other backbone networks, you need to ensure that the output channels of the backbone network match the input channels of the neck network. +2. The configuration files given below only ensure that the training will work correctly, and their training performance may not be optimal. Because some backbones require specific learning rates, optimizers, and other hyperparameters. Related contents will be added in the "Training Tips" section later. +``` + +## Use backbone network implemented in MMYOLO + +Suppose you want to use `YOLOv6EfficientRep` as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + backbone=dict( + type='YOLOv6EfficientRep', + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True)) +) +``` + +## Use backbone network implemented in other OpenMMLab repositories + +The model registry in MMYOLO, MMDetection, MMClassification, and MMSegmentation all inherit from the root registry in MMEngine in the OpenMMLab 2.0 system, allowing these repositories to directly use modules already implemented by each other. Therefore, in MMYOLO, users can use backbone networks from MMDetection and MMClassification without reimplementation. + +### Use backbone network implemented in MMDetection + +1. Suppose you want to use `ResNet-50` as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [512, 1024, 2048] + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmdet.ResNet', # Using ResNet from mmdet + depth=50, + num_stages=4, + out_indices=(1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='YOLOv5PAFPN', + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of ResNet-50 output are [512, 1024, 2048], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` + +2. Suppose you want to use `SwinTransformer-Tiny` as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [192, 384, 768] +checkpoint_file = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmdet.SwinTransformer', # Using SwinTransformer from mmdet + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)), + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of SwinTransformer-Tiny output are [192, 384, 768], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` + +### Use backbone network implemented in MMClassification + +1. Suppose you want to use `ConvNeXt-Tiny` as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +# please run the command, mim install "mmcls>=1.0.0rc2", to install mmcls +# import mmcls.models to trigger register_module in mmcls +custom_imports = dict(imports=['mmcls.models'], allow_failed_imports=False) +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth' # noqa +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [192, 384, 768] + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmcls.ConvNeXt', # Using ConvNeXt from mmcls + arch='tiny', + out_indices=(1, 2, 3), + drop_path_rate=0.4, + layer_scale_init_value=1.0, + gap_before_final_norm=False, + init_cfg=dict( + type='Pretrained', checkpoint=checkpoint_file, + prefix='backbone.')), # The pre-trained weights of backbone network in MMCls have prefix='backbone.'. The prefix in the keys will be removed so that these weights can be normally loaded. + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of ConvNeXt-Tiny output are [192, 384, 768], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` + +2. Suppose you want to use `MobileNetV3-small` as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +# please run the command, mim install "mmcls>=1.0.0rc2", to install mmcls +# import mmcls.models to trigger register_module in mmcls +custom_imports = dict(imports=['mmcls.models'], allow_failed_imports=False) +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/mobilenet_v3/convert/mobilenet_v3_small-8427ecf0.pth' # noqa +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [24, 48, 96] + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmcls.MobileNetV3', # Using MobileNetV3 from mmcls + arch='small', + out_indices=(3, 8, 11), # Modify out_indices + init_cfg=dict( + type='Pretrained', + checkpoint=checkpoint_file, + prefix='backbone.')), # The pre-trained weights of backbone network in MMCls have prefix='backbone.'. The prefix in the keys will be removed so that these weights can be normally loaded. + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of MobileNetV3 output are [24, 48, 96], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` + +### Use backbone network in `timm` through MMClassification + +MMClassification also provides a wrapper for the Py**T**orch **Im**age **M**odels (`timm`) backbone network, users can directly use the backbone network in `timm` through MMClassification. Suppose you want to use `EfficientNet-B1` as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +# please run the command, mim install "mmcls>=1.0.0rc2", to install mmcls +# and the command, pip install timm, to install timm +# import mmcls.models to trigger register_module in mmcls +custom_imports = dict(imports=['mmcls.models'], allow_failed_imports=False) + +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [40, 112, 320] + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmcls.TIMMBackbone', # Using timm from mmcls + model_name='efficientnet_b1', # Using efficientnet_b1 in timm + features_only=True, + pretrained=True, + out_indices=(2, 3, 4)), + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of EfficientNet-B1 output are [40, 112, 320], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` + +### Use backbone network implemented in MMSelfSup + +Suppose you want to use `ResNet-50` which is self-supervised trained by `MoCo v3` in MMSelfSup as the backbone network of `YOLOv5`, the example config is as the following: + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +# please run the command, mim install "mmselfsup>=1.0.0rc3", to install mmselfsup +# import mmselfsup.models to trigger register_module in mmselfsup +custom_imports = dict(imports=['mmselfsup.models'], allow_failed_imports=False) +checkpoint_file = 'https://download.openmmlab.com/mmselfsup/1.x/mocov3/mocov3_resnet50_8xb512-amp-coslr-800e_in1k/mocov3_resnet50_8xb512-amp-coslr-800e_in1k_20220927-e043f51a.pth' # noqa +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [512, 1024, 2048] + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmselfsup.ResNet', + depth=50, + num_stages=4, + out_indices=(2, 3, 4), # Note: out_indices of ResNet in MMSelfSup are 1 larger than those in MMdet and MMCls + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint=checkpoint_file)), + neck=dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of ResNet-50 output are [512, 1024, 2048], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` + +### Don't used pre-training weights + +When we replace the backbone network, the model initialization is trained by default loading the pre-training weight of the backbone network. Instead of using the pre-training weights of the backbone network, if you want to train the time model from scratch, +You can set `init_cfg` in 'backbone' to 'None'. In this case, the backbone network will be initialized with the default initialization method, instead of using the trained pre-training weight. + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +deepen_factor = _base_.deepen_factor +widen_factor = 1.0 +channels = [512, 1024, 2048] + +model = dict( + backbone=dict( + _delete_=True, # Delete the backbone field in _base_ + type='mmdet.ResNet', # Using ResNet from mmdet + depth=50, + num_stages=4, + out_indices=(1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=None # If init_cfg is set to None, backbone will not be initialized with pre-trained weights + ), + neck=dict( + type='YOLOv5PAFPN', + widen_factor=widen_factor, + in_channels=channels, # Note: The 3 channels of ResNet-50 output are [512, 1024, 2048], which do not match the original yolov5-s neck and need to be changed. + out_channels=channels), + bbox_head=dict( + type='YOLOv5Head', + head_module=dict( + type='YOLOv5HeadModule', + in_channels=channels, # input channels of head need to be changed accordingly + widen_factor=widen_factor)) +) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/training_testing_tricks.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/training_testing_tricks.md new file mode 100644 index 0000000000000000000000000000000000000000..48ce25f8bd1708727e2738ff2e81035e20b16466 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/training_testing_tricks.md @@ -0,0 +1,310 @@ +# Training testing tricks + +MMYOLO has already supported most of the YOLO series object detection related algorithms. Different algorithms may involve some practical tricks. This section will describe in detail the commonly used training and testing tricks supported by MMYOLO based on the implemented object detection algorithms. + +## Training tricks + +### Improve performance of detection + +#### 1. Multi-scale training + +In the field of object detection, multi-scale training is a very common trick. However, in YOLO, most of the models are trained with a single-scale input of 640x640. There are two reasons for this: + +1. Single-scale training is faster than multi-scale training. When the training epoch is at 300 or 500, training efficiency is a major concern for users. Multi-scale training will be slower. +2. Multi-scale augmentation is implied in the training pipeline, which is equivalent to the application of multi-scale training, such as the 'Mosaic', 'RandomAffine' and 'Resize', so there is no need to introduce the multi-scale training of model input again. + +Through experiments on the COCO dataset, it is founded that the multi-scale training is introduced directly after the output of YOLOv5's DataLoader, the actual performance improvement is very small. If you want to start multi-scale training for YOLO series algorithms in MMYOLO, you can refer to [ms_training_testing](../common_usage/ms_training_testing.md), +however, this does not mean that there are no significant gains in user-defined dataset fine-tuning mode + +#### 2 Use Mask annotation to optimize object detection performance + +When the dataset annotation is complete, such as boundary box annotation and instance segmentation annotation exist at the same time, but only part of the annotation is required for the task, the task can be trained with complete data annotation to improve the performance. +In object detection, we can also learn from instance segmentation annotation to improve the performance of object detection. The following is the detection result of additional instance segmentation annotation optimization introduced by YOLOv8. The performance gains are shown below: + +
+ +
+ +As shown in the figure, different scale models have different degrees of performance improvement. +It is important to note that 'Mask Refine' only functions in the data enhancement phase and does not require any changes to other training parts of the model and does not affect the speed of training. The details are as follows: + +
+ +
+ +The above-mentioned Mask represents a data augmentation transformation in which instance segmentation annotations play a key role. +The application of this technique to other YOLO series has varying degrees of increase. + +#### 3 Turn off strong augmentation in the later stage of training to improve detection performance + +This strategy is proposed for the first time in YOLOX algorithm and can greatly improve the detection performance. +The paper points out that Mosaic+MixUp can greatly improve the target detection performance, but the training pictures are far from the real distribution of natural pictures, and Mosaic's large number of cropping operations will bring many inaccurate label boxes, +therefore, YOLOX proposes to turn off the strong enhancement in the last 15 epochs and use the weaker enhancement instead, so that the detector can avoid the influence of inaccurate labeled boxes and complete the final convergence under the data distribution of the natural picture. + +This strategy has been applied to most YOLO algorithms. Taking YOLOv8 as an example, its data augmentation pipeline is shown as follows: + +
+ +
+ +However, when to turn off the strong augmentation is a hyper-parameter. If you turn off the strong augmentation too early, it may not give full play to Mosaic and other strong augmentation effects. If you turn off the strong enhancement too late, it will have no gain because it has been overfitted before. This phenomenon can be observed in YOLOv8 experiment + +| Backbone | Mask Refine | box AP | Epoch of best mAP | +| :------: | :---------: | :---------: | :---------------: | +| YOLOv8-n | No | 37.2 | 500 | +| YOLOv8-n | Yes | 37.4 (+0.2) | 499 | +| YOLOv8-s | No | 44.2 | 430 | +| YOLOv8-s | Yes | 45.1 (+0.9) | 460 | +| YOLOv8-m | No | 49.8 | 460 | +| YOLOv8-m | Yes | 50.6 (+0.8) | 480 | +| YOLOv8-l | No | 52.1 | 460 | +| YOLOv8-l | Yes | 53.0 (+0.9) | 491 | +| YOLOv8-x | No | 52.7 | 450 | +| YOLOv8-x | Yes | 54.0 (+1.3) | 460 | + +As can be seen from the above table: + +- Large models trained on COCO dataset for 500 epochs are prone to overfitting, and disabling strong augmentations such as Mosaic may not be effective in reducing overfitting in such cases. +- Using Mask annotations can alleviate overfitting and improve performance + +#### 4 Add pure background images to suppress false positives + +For non-open-world datasets in object detection, both training and testing are conducted on a fixed set of classes, and there is a possibility of producing false positives when applied to images with classes that have not been trained. A common mitigation strategy is to add a certain proportion of pure background images. +In most YOLO series, the function of suppressing false positives by adding pure background images is enabled by default. Users only need to set train_dataloader.dataset.filter_cfg.filter_empty_gt to False, indicating that pure background images should not be filtered out during training. + +#### 5 Maybe the AdamW works wonders + +YOLOv5, YOLOv6, YOLOv7 and YOLOv8 all adopt the SGD optimizer, which is strict about parameter settings, while AdamW is on the contrary, which is not so sensitive to learning rate. If user fine-tune a custom-dataset can try to select the AdamW optimizer. We did a simple trial in YOLOX and found that replacing the optimizer with AdamW on the tiny, s, and m scale models all had some improvement. + +| Backbone | Size | Batch Size | RTMDet-Hyp | Box AP | +| :--------: | :--: | :--------: | :--------: | :---------: | +| YOLOX-tiny | 416 | 8xb8 | No | 32.7 | +| YOLOX-tiny | 416 | 8xb32 | Yes | 34.3 (+1.6) | +| YOLOX-s | 640 | 8xb8 | No | 40.7 | +| YOLOX-s | 640 | 8xb32 | Yes | 41.9 (+1.2) | +| YOLOX-m | 640 | 8xb8 | No | 46.9 | +| YOLOX-m | 640 | 8xb32 | Yes | 47.5 (+0.6) | + +More details can be found in [configs/yolox/README.md](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolox/README.md#--results-and-models). + +#### 6 Consider ignore scenarios to avoid uncertain annotations + +Take CrowdHuman as an example, a crowded pedestrian detection dataset. Here's a typical image: + +
+ +
+ +The image is sourced from [detectron2 issue](https://github.com/facebookresearch/detectron2/issues/1909). The area marked with a yellow cross indicates the `iscrowd` label. There are two reasons for this: + +- This area is not a real person, such as the person on the poster +- The area is too crowded to mark + +In this scenario, you cannot simply delete such annotations, because once you delete them, it means treating them as background areas during training. However, they are different from the background. Firstly, the people on the posters are very similar to real people, and there are indeed people in crowded areas that are difficult to annotate. If you simply train them as background, it will cause false negatives. The best approach is to treat the crowded area as an ignored region, where any output in this area is directly ignored, with no loss calculated and no model fitting enforced. + +MMYOLO quickly and easily verifies the function of 'iscrowd' annotation on YOLOv5. The performance is as follows: + +| Backbone | ignore_iof_thr | box AP50(CrowDHuman Metric) | MR | JI | +| :------: | :------------: | :-------------------------: | :--: | :---: | +| YOLOv5-s | -1 | 85.79 | 48.7 | 75.33 | +| YOLOv5-s | 0.5 | 86.17 | 48.8 | 75.87 | + +`ignore_iof_thr` set to -1 indicates that the ignored labels are not considered, and it can be seen that the performance is improved to a certain extent, more details can be found in [CrowdHuman results](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/README.md#crowdhuman). If you encounter similar situations in your custom dataset, it is recommended that you consider using `ignore` labels to avoid uncertain annotations. + +#### 7 Use knowledge distillation + +Knowledge distillation is a widely used technique that can transfer the performance of a large model to a smaller model, thereby improving the detection performance of the smaller model. Currently, MMYOLO and MMRazor have supported this feature and conducted initial verification on RTMDet. + +| Model | box AP | +| :------------: | :---------: | +| RTMDet-tiny | 41.0 | +| RTMDet-tiny \* | 41.8 (+0.8) | +| RTMDet-s | 44.6 | +| RTMDet-s \* | 45.7 (+1.1) | +| RTMDet-m | 49.3 | +| RTMDet-m \* | 50.2 (+0.9) | +| RTMDet-l | 51.4 | +| RTMDet-l \* | 52.3 (+0.9) | + +`*` indicates the result of using the large model distillation, more details can be found in [Distill RTMDet](https://github.com/open-mmlab/mmyolo/tree/main/configs/rtmdet/distillation). + +#### 8 Stronger augmentation parameters are used for larger models + +If you have modified the model based on the default configuration or replaced the backbone network, it is recommended to scale the data augmentation parameters based on the current model size. Generally, larger models require stronger augmentation parameters, otherwise they may not fully leverage the benefits of large models. Conversely, if strong augmentations are applied to small models, it may result in underfitting. Taking RTMDet as an example, we can observe the data augmentation parameters for different model sizes. + +
+ +
+ +`random_resize_ratio_range` represents the random scaling range of `RandomResize`, and `mosaic_max_cached_images/mixup_max_cached_images` represents the number of cached images during `Mosaic/MixUp` augmentation, which can be used to adjust the strength of augmentation. The YOLO series models all follow the same set of parameter settings principles. + +### Accelerate training speed + +#### 1 Enable cudnn_benchmark for single-scale training + +Most of the input image sizes in the YOLO series algorithms are fixed, which is single-scale training. In this case, you can turn on cudnn_benchmark to accelerate the training speed. This parameter is mainly set for PyTorch's cuDNN underlying library, and setting this flag can allow the built-in cuDNN to automatically find the most efficient algorithm that is best suited for the current configuration to optimize the running efficiency. If this flag is turned on in multi-scale mode, it will continuously search for the optimal algorithm, which may slow down the training speed instead. + +To enable `cudnn_benchmark` in MMYOLO, you can set `env_cfg = dict(cudnn_benchmark=True)` in the configuration. + +#### 2 Use Mosaic and MixUp with caching + +If you have applied Mosaic and MixUp in your data augmentation, and after investigating the training bottleneck, it is found that the random image reading is causing the issue, then it is recommended to replace the regular Mosaic and MixUp with the cache-enabled versions proposed in RTMDet. + +| Data Aug | Use cache | ms/100 imgs | +| :------: | :-------: | :---------: | +| Mosaic | No | 87.1 | +| Mosaic | Yes | 24.0 | +| MixUp | No | 19.3 | +| MixUp | Yes | 12.4 | + +Mosaic and MixUp involve mixing multiple images, and their time consumption is K times that of ordinary data augmentation (K is the number of images mixed). For example, in YOLOv5, when doing Mosaic each time, the information of 4 images needs to be reloaded from the hard disk. However, the cached version of Mosaic and MixUp only needs to reload the current image, while the remaining images involved in the mixed augmentation are obtained from the cache queue, greatly improving efficiency by sacrificing a certain amount of memory space. + +
+data cache +
+ +As shown in the figure, N preloaded images and label data are stored in the cache queue. In each training step, only one new image and its label data need to be loaded and updated in the cache queue. (Images in the cache queue can be duplicated, as shown in the figure with img3 appearing twice.) If the length of the cache queue exceeds the preset length, a random image will be popped out. When it is necessary to perform mixed data augmentation, only the required images need to be randomly selected from the cache for concatenation or other processing, without the need to load all images from the hard disk, thus saving image loading time. + +### Reduce the number of hyperparameter + +YOLOv5 provides some practical methods for reducing the number of hyperparameter, which are described below. + +#### 1 Adaptive loss weighting, reducing one hyperparameter + +In general, it can be challenging to set hyperparameters specifically for different tasks or categories. YOLOv5 proposes some adaptive methods for scaling loss weights based on the number of classes and the number of detection output layers have been proposed based on practical experience, as shown below: + +```python +# scaled based on number of detection layers +loss_cls=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=loss_cls_weight * + (num_classes / 80 * 3 / num_det_layers)), +loss_bbox=dict( + type='IoULoss', + iou_mode='ciou', + bbox_format='xywh', + eps=1e-7, + reduction='mean', + loss_weight=loss_bbox_weight * (3 / num_det_layer + return_iou=True), +loss_obj=dict( + type='mmdet.CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=loss_obj_weight * + ((img_scale[0] / 640)**2 * 3 / num_det_layers)), +``` + +`loss_cls` can adaptively scale `loss_weight` based on the custom number of classes and the number of detection layers, `loss_bbox` can adaptively calculate based on the number of detection layers, and `loss_obj` can adaptively scale based on the input image size and the number of detection layers. This strategy allows users to avoid setting Loss weight hyperparameters. +It should be noted that this is only an empirical principle and not necessarily the optimal setting combination, it should be used as a reference. + +#### 2 Adaptive Weight Decay and Loss output values base on Batch Size, reducing two hyperparameters + +In general,when training on different `Batch Size`, it is necessary to follow the rule of automatic learning rate scaling. However, validation on various datasets shows that YOLOv5 can achieve good results without scaling the learning rate when changing the Batch Size, and sometimes scaling can even lead to worse results. The reason lies in the technique of `Weight Decay` and Loss output based on `Batch Size` adaptation in the code. In YOLOv5, `Weight Decay` and Loss output values will be scaled based on the total `Batch Size` being trained. The corresponding code is: + +```python +# https://github.com/open-mmlab/mmyolo/blob/dev/mmyolo/engine/optimizers/yolov5_optim_constructor.py#L86 +if 'batch_size_per_gpu' in optimizer_cfg: + batch_size_per_gpu = optimizer_cfg.pop('batch_size_per_gpu') + # No scaling if total_batch_size is less than + # base_total_batch_size, otherwise linear scaling. + total_batch_size = get_world_size() * batch_size_per_gpu + accumulate = max( + round(self.base_total_batch_size / total_batch_size), 1) + scale_factor = total_batch_size * \ + accumulate / self.base_total_batch_size + if scale_factor != 1: + weight_decay *= scale_factor + print_log(f'Scaled weight_decay to {weight_decay}', 'current') +``` + +```python +# https://github.com/open-mmlab/mmyolo/blob/dev/mmyolo/models/dense_heads/yolov5_head.py#L635 + _, world_size = get_dist_info() + return dict( + loss_cls=loss_cls * batch_size * world_size, + loss_obj=loss_obj * batch_size * world_size, + loss_bbox=loss_box * batch_size * world_size) +``` + +The weight of Loss varies in different Batch Sizes, and generally, the larger Batch Size means most larger the Loss and gradient. I personally speculate that this can be equivalent to a scenario of linearly increasing learning rate when Batch Size increases. +In fact, from the [YOLOv5 Study: mAP vs Batch-Size](https://github.com/ultralytics/yolov5/discussions/2452) of YOLOv5, it can be found that it is desirable for users to achieve similar performance without modifying other parameters when modifying the Batch Size. The above two strategies are very good training techniques. + +### Save memory on GPU + +How to reduce training memory usage is a frequently discussed issue, and there are many techniques involved. The training executor of MMYOLO comes from MMEngine, so you can refer to the MMEngine documentation for how to reduce training memory usage. Currently, MMEngine supports gradient accumulation, gradient checkpointing, and large model training techniques, details of which can be found in the +[SAVE MEMORY ON GPU](https://mmengine.readthedocs.io/zh_CN/latest/common_usage/save_gpu_memory.html). + +## Testing trick + +### Balance between inference speed and testing accuracy + +During model performance testing, we generally require a higher mAP, but in practical applications or inference, we want the model to perform faster while maintaining low false positive and false negative rates. In other words, the testing only focuses on mAP while ignoring post-processing and evaluation speed, while in practical applications, a balance between speed and accuracy is pursued. +In the YOLO series, it is possible to achieve a balance between speed and accuracy by controlling certain parameters. In this example, we will describe this in detail using YOLOv5. + +#### 1 Avoiding multiple class outputs for a single detection box during inference + +YOLOv5 uses BCE Loss (use_sigmoid=True) during the training of the classification branch. Assuming there are 4 object categories, the number of categories output by the classification branch is 4 instead of 5. Moreover, due to the use of sigmoid instead of softmax prediction, it is possible to predict multiple detection boxes that meet the filtering threshold at a certain position, which means that there may be a situation where one predicted bbox corresponds to multiple predicted labels. This is shown in the figure below: + +
+multi-label +
+ +Generally, when calculating mAP, the filtering threshold is set to 0.001. Due to the non-competitive prediction mode of sigmoid, one box may correspond to multiple labels. This calculation method can increase the recall rate when calculating mAP, but it may not be convenient for practical applications. + +One common approach is to increase the filtering threshold. However, if you don't want to have many false negatives, it is recommended to set the `multi_label` parameter to False. It is located in the configuration file at `mode.test_cfg.multi_label` and its default value is True, which allows one detection box to correspond to multiple labels. + +#### 2 Simplify test pipeline + +Note that the test pipeline for YOLOv5 is as follows: + +```python +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +``` + +It uses two different Resizes with different functions, with the aim of improving the mAP value during evaluation. In actual deployment, you can simplify this pipeline as shown below: + +```python +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='LetterResize', + scale=_base_.img_scale, + allow_scale_up=True, + use_mini_pad=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +``` + +In practical applications, YOLOv5 algorithm uses a simplified pipeline with multi_label set to False, score_thr increased to 0.25, and iou_threshold reduced to 0.45. +In the YOLOv5 configuration, we provide a set of configuration parameters for detection on the ground, as detailed in [yolov5_s-v61_syncbn-detect_8xb16-300e_coco.py](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/yolov5_s-v61_syncbn-detect_8xb16-300e_coco.py). + +#### 3 Batch Shape speeds up the testing speed + +Batch Shape is a testing technique proposed in YOLOv5 that can speed up inference. The idea is to no longer require that all images in the testing process be 640x640, but to test at variable scales, as long as the shapes within the current batch are the same. This approach can reduce additional image pixel padding and speed up the inference process. The specific implementation of Batch Shape can be found in the [link](https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/datasets/utils.py#L55). +Almost all algorithms in MMYOLO default to enabling the Batch Shape strategy during testing. If users want to disable this feature, you can set `val_dataloader.dataset.batch_shapes_cfg=None`. + +In practical applications, because dynamic shape is not as fast and efficient as fixed shape. Therefore, this strategy is generally not used in real-world scenarios. + +### TTA improves test accuracy + +Data augmentation with TTA (Test Time Augmentation) is a versatile trick that can improve the performance of object detection models and is particularly useful in competition scenarios. MMYOLO has already supported TTA, and it can be enabled simply by adding `--tta` when testing. For more details, please refer to the [TTA](https://github.com/open-mmlab/mmyolo/blob/dev/docs/zh_cn/common_usage/tta.md). diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/troubleshooting_steps.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/troubleshooting_steps.md new file mode 100644 index 0000000000000000000000000000000000000000..60cc1143f3db6556b8491ec0037df174c2fe823b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/troubleshooting_steps.md @@ -0,0 +1 @@ +# Troubleshooting steps for common errors diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/visualization.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/visualization.md new file mode 100644 index 0000000000000000000000000000000000000000..f986648f385d1798663209812163dc3d87bce755 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/recommended_topics/visualization.md @@ -0,0 +1,346 @@ +# Visualization + +This article includes feature map visualization and Grad-Based and Grad-Free CAM visualization + +## Feature map visualization + +
+image +
+ +Visualization provides an intuitive explanation of the training and testing process of the deep learning model. + +In MMYOLO, you can use the `Visualizer` provided in MMEngine for feature map visualization, which has the following features: + +- Support basic drawing interfaces and feature map visualization. +- Support selecting different layers in the model to get the feature map. The display methods include `squeeze_mean`, `select_max`, and `topk`. Users can also customize the layout of the feature map display with `arrangement`. + +### Feature map generation + +You can use `demo/featmap_vis_demo.py` to get a quick view of the visualization results. To better understand all functions, we list all primary parameters and their features here as follows: + +- `img`: the image to visualize. Can be either a single image file or a list of image file paths. + +- `config`: the configuration file for the algorithm. + +- `checkpoint`: the weight file of the corresponding algorithm. + +- `--out-file`: the file path to save the obtained feature map on your device. + +- `--device`: the hardware used for image inference. For example, `--device cuda:0` means use the first GPU, whereas `--device cpu` means use CPU. + +- `--score-thr`: the confidence score threshold. Only bboxes whose confidence scores are higher than this threshold will be displayed. + +- `--preview-model`: if there is a need to preview the model. This could make users understand the structure of the feature layer more straightforwardly. + +- `--target-layers`: the specific layer to get the visualized feature map result. + + - If there is only one parameter, the feature map of that specific layer will be visualized. For example, `--target-layers backbone` , `--target-layers neck` , `--target-layers backbone.stage4`, etc. + - If the parameter is a list, all feature maps of the corresponding layers will be visualized. For example, `--target-layers backbone.stage4 neck` means that the stage4 layer of the backbone and the three layers of the neck are output simultaneously, a total of four layers of feature maps. + +- `--channel-reduction`: if needs to compress multiple channels into a single channel and then display it overlaid with the picture as the input tensor usually has multiple channels. Three parameters can be used here: + + - `squeeze_mean`: The input channel C will be compressed into one channel using the mean function, and the output dimension becomes (1, H, W). + - `select_max`: Sum the input channel C in the spatial space, and the dimension becomes (C, ). Then select the channel with the largest value. + - `None`: Indicates that no compression is required. In this case, the `topk` feature maps with the highest activation degree can be selected to display through the `topk` parameter. + +- `--topk`: only valid when the `channel_reduction` parameter is `None`. It selects the `topk` channels according to the activation degree and then displays it overlaid with the image. The display layout can be specified using the `--arrangement` parameter, which is an array of two numbers separated by space. For example, `--topk 5 --arrangement 2 3` means the five feature maps with the highest activation degree are displayed in `2 rows and 3 columns`. Similarly, `--topk 7 --arrangement 3 3` means the seven feature maps with the highest activation degree are displayed in `3 rows and 3 columns`. + + - If `topk` is not -1, topk channels will be selected to display in order of the activation degree. + - If `topk` is -1, channel number C must be either 1 or 3 to indicate that the input data is a picture. Otherwise, an error will prompt the user to compress the channel with `channel_reduction`. + +- Considering that the input feature map is usually very small, the function will upsample the feature map by default for easy visualization. + +**Note: When the image and feature map scales are different, the `draw_featmap` function will automatically perform an upsampling alignment. If your image has an operation such as `Pad` in the preprocessing during the inference, the feature map obtained is processed with `Pad`, which may cause misalignment problems if you directly upsample the image.** + +### Usage examples + +Take the pre-trained YOLOv5-s model as an example. Please download the model weight file to the root directory. + +```shell +cd mmyolo +wget https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth +``` + +(1) Compress the multi-channel feature map into a single channel with `select_max` and display it. By extracting the output of the `backbone` layer for visualization, the feature maps of the three output layers in the `backbone` will be generated: + +```shell +python demo/featmap_vis_demo.py demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --target-layers backbone \ + --channel-reduction select_max +``` + +
+image +
+ +The above code has the problem that the image and the feature map need to be aligned. There are two solutions for this: + +1. Change the post-process to simple `Resize` in the YOLOv5 configuration, which does not affect visualization. + +2. Use the images after the pre-process stage instead of before the pre-process when visualizing. + +**For simplicity purposes, we take the first solution in this demo. However, the second solution will be made in the future so that everyone can use it without extra modification on the configuration file**. More specifically, change the original `test_pipeline` with the version with Resize process only. + +The original `test_pipeline` is: + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +``` + +Change to the following version: + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # change the LetterResize to mmdet.Resize + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +``` + +The correct result is shown as follows: + +
+image +
+ +(2) Compress the multi-channel feature map into a single channel using the `squeeze_mean` parameter and display it. By extracting the output of the `neck` layer for visualization, the feature maps of the three output layers of `neck` will be generated: + +```shell +python demo/featmap_vis_demo.py demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --target-layers neck \ + --channel-reduction squeeze_mean +``` + +
+image +
+ +(3) Compress the multi-channel feature map into a single channel using the `squeeze_mean` parameter and display it. Then, visualize the feature map by extracting the outputs of the `backbone.stage4` and `backbone.stage3` layers, and the feature maps of the two output layers will be generated: + +```shell +python demo/featmap_vis_demo.py demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --target-layers backbone.stage4 backbone.stage3 \ + --channel-reduction squeeze_mean +``` + +
+image +
+ +(4) Use the `--topk 3 --arrangement 2 2` parameter to select the top 3 channels with the highest activation degree in the multi-channel feature map and display them in a `2x2` layout. Users can change the layout to what they want through the `arrangement` parameter, and the feature map will be automatically formatted. First, the `top3` feature map in each layer is formatted in a `2x2` shape, and then each layer is formatted in `2x2` as well: + +```shell +python demo/featmap_vis_demo.py demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --target-layers backbone.stage3 backbone.stage4 \ + --channel-reduction None \ + --topk 3 \ + --arrangement 2 2 +``` + +
+image +
+ +(5) When the visualization process finishes, you can choose to display the result or store it locally. You only need to add the parameter `--out-file xxx.jpg`: + +```shell +python demo/featmap_vis_demo.py demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --target-layers backbone \ + --channel-reduction select_max \ + --out-file featmap_backbone.jpg +``` + +## Grad-Based and Grad-Free CAM Visualization + +Object detection CAM visualization is much more complex and different than classification CAM. +This article only briefly explains the usage, and a separate document will be opened to describe the implementation principles and precautions in detail later. + +You can call `demo/boxmap_vis_demo.py` to get the AM visualization results at the Box level easily and quickly. Currently, `YOLOv5/YOLOv6/YOLOX/RTMDet` is supported. + +Taking YOLOv5 as an example, as with the feature map visualization, you need to modify the `test_pipeline` first, otherwise there will be a problem of misalignment between the feature map and the original image. + +The original `test_pipeline` is: + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] +``` + +Change to the following version: + +```python +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='mmdet.Resize', scale=img_scale, keep_ratio=False), # change the LetterResize to mmdet.Resize + dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +``` + +(1) Use the `GradCAM` method to visualize the AM of the last output layer of the neck module + +```shell +python demo/boxam_vis_demo.py \ + demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth +``` + +
+image +
+ +The corresponding feature AM is as follows: + +
+image +
+ +It can be seen that the `GradCAM` effect can highlight the AM information at the box level. + +You can choose to visualize only the top prediction boxes with the highest prediction scores via the `--topk` parameter + +```shell +python demo/boxam_vis_demo.py \ + demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --topk 2 +``` + +
+image +
+ +(2) Use the AblationCAM method to visualize the AM of the last output layer of the neck module + +```shell +python demo/boxam_vis_demo.py \ + demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --method ablationcam +``` + +
+image +
+ +Since `AblationCAM` is weighted by the contribution of each channel to the score, it is impossible to visualize only the AM information at the box level like `GradCAN`. But you can use `--norm-in-bbox` to only show bbox inside AM + +```shell +python demo/boxam_vis_demo.py \ + demo/dog.jpg \ + configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth \ + --method ablationcam \ + --norm-in-bbox +``` + +
+image +
+ +## Perform inference on large images + +First install [`sahi`](https://github.com/obss/sahi) with: + +```shell +pip install -U sahi>=0.11.4 +``` + +Perform MMYOLO inference on large images (as satellite imagery) as: + +```shell +wget -P checkpoint https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth + +python demo/large_image_demo.py \ + demo/large_image.jpg \ + configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py \ + checkpoint/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth \ +``` + +Arrange slicing parameters as: + +```shell +python demo/large_image_demo.py \ + demo/large_image.jpg \ + configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py \ + checkpoint/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth \ + --patch-size 512 + --patch-overlap-ratio 0.25 +``` + +Export debug visuals while performing inference on large images as: + +```shell +python demo/large_image_demo.py \ + demo/large_image.jpg \ + configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py \ + checkpoint/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth \ + --debug +``` + +[`sahi`](https://github.com/obss/sahi) citation: + +``` +@article{akyon2022sahi, + title={Slicing Aided Hyper Inference and Fine-tuning for Small Object Detection}, + author={Akyon, Fatih Cagatay and Altinuc, Sinan Onur and Temizel, Alptekin}, + journal={2022 IEEE International Conference on Image Processing (ICIP)}, + doi={10.1109/ICIP46576.2022.9897990}, + pages={966-970}, + year={2022} +} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/stat.py b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/stat.py new file mode 100644 index 0000000000000000000000000000000000000000..6c8afcc7bd287b3287452095cbeb3cfa0aaf0fef --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/stat.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python +import functools as func +import glob +import os.path as osp +import re + +import numpy as np + +url_prefix = 'https://github.com/open-mmlab/mmdetection/blob/3.x/configs' + +files = sorted(glob.glob('../../configs/*/README.md')) + +stats = [] +titles = [] +num_ckpts = 0 + +for f in files: + url = osp.dirname(f.replace('../../configs', url_prefix)) + + with open(f) as content_file: + content = content_file.read() + + title = content.split('\n')[0].replace('# ', '').strip() + ckpts = { + x.lower().strip() + for x in re.findall(r'\[model\]\((https?.*)\)', content) + } + + if len(ckpts) == 0: + continue + + _papertype = [x for x in re.findall(r'\[([A-Z]+)\]', content)] + assert len(_papertype) > 0 + papertype = _papertype[0] + + paper = {(papertype, title)} + + titles.append(title) + num_ckpts += len(ckpts) + + statsmsg = f""" +\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts) +""" + stats.append((paper, ckpts, statsmsg)) + +allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats]) +msglist = '\n'.join(x for _, _, x in stats) + +papertypes, papercounts = np.unique([t for t, _ in allpapers], + return_counts=True) +countstr = '\n'.join( + [f' - {t}: {c}' for t, c in zip(papertypes, papercounts)]) + +modelzoo = f""" +# Model Zoo Statistics + +* Number of papers: {len(set(titles))} +{countstr} + +* Number of checkpoints: {num_ckpts} + +{msglist} +""" + +with open('modelzoo_statistics.md', 'w') as f: + f.write(modelzoo) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/switch_language.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/switch_language.md new file mode 100644 index 0000000000000000000000000000000000000000..57b71ebfe41843c8bc8ad29d01d4657f0770465e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/switch_language.md @@ -0,0 +1,3 @@ +## English + +## 简体中文 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/config.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/config.md new file mode 100644 index 0000000000000000000000000000000000000000..448452243ec9f6dd9bf6e2ef2fee7c2451b48e7e --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/config.md @@ -0,0 +1,556 @@ +# Learn about Configs with YOLOv5 + +MMYOLO and other OpenMMLab repositories use [MMEngine's config system](https://mmengine.readthedocs.io/en/latest/tutorials/config.html). It has a modular and inheritance design, which is convenient to conduct various experiments. + +## Config file content + +MMYOLO uses a modular design, all modules with different functions can be configured through the config. Taking [yolov5_s-v61_syncbn_8xb16-300e_coco.py](https://github.com/open-mmlab/mmyolo/blob/main/configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py) as an example, we will introduce each field in the config according to different function modules: + +### Important parameters + +When changing the training configuration, it is usually necessary to modify the following parameters. For example, the scaling factors `deepen_factor` and `widen_factor` are used by the network to control the size of the model in MMYOLO. So we recommend defining these parameters separately in the configuration file. + +```python +img_scale = (640, 640) # height of image, width of image +deepen_factor = 0.33 # The scaling factor that controls the depth of the network structure, 0.33 for YOLOv5-s +widen_factor = 0.5 # The scaling factor that controls the width of the network structure, 0.5 for YOLOv5-s +max_epochs = 300 # Maximum training epochs: 300 epochs +save_epoch_intervals = 10 # Validation intervals. Run validation every 10 epochs. +train_batch_size_pre_gpu = 16 # Batch size of a single GPU during training +train_num_workers = 8 # Worker to pre-fetch data for each single GPU +val_batch_size_pre_gpu = 1 # Batch size of a single GPU during validation. +val_num_workers = 2 # Worker to pre-fetch data for each single GPU during validation +``` + +### Model config + +In MMYOLO's config, we use `model` to set up detection algorithm components. In addition to neural network components such as `backbone`, `neck`, etc, it also requires `data_preprocessor`, `train_cfg`, and `test_cfg`. `data_preprocessor` is responsible for processing a batch of data output by the dataloader. `train_cfg` and `test_cfg` in the model config are for training and testing hyperparameters of the components. + +```python +anchors = [[(10, 13), (16, 30), (33, 23)], # Basic size of multi-scale prior box + [(30, 61), (62, 45), (59, 119)], + [(116, 90), (156, 198), (373, 326)]] +strides = [8, 16, 32] # Strides of multi-scale prior box + +model = dict( + type='YOLODetector', # The name of detector + data_preprocessor=dict( # The config of data preprocessor, usually includes image normalization and padding + type='mmdet.DetDataPreprocessor', # The type of the data preprocessor, refer to https://mmdetection.readthedocs.io/en/dev-3.x/api.html#module-mmdet.models.data_preprocessors. It is worth noticing that using `YOLOv5DetDataPreprocessor` achieves faster training speed. + mean=[0., 0., 0.], # Mean values used to pre-training the pre-trained backbone models, ordered in R, G, B + std=[255., 255., 255.], # Standard variance used to pre-training the pre-trained backbone models, ordered in R, G, B + bgr_to_rgb=True), # whether to convert image from BGR to RGB + backbone=dict( # The config of backbone + type='YOLOv5CSPDarknet', # The type of backbone, currently it is available candidates are 'YOLOv5CSPDarknet', 'YOLOv6EfficientRep', 'YOLOXCSPDarknet' + deepen_factor=deepen_factor, # The scaling factor that controls the depth of the network structure + widen_factor=widen_factor, # The scaling factor that controls the width of the network structure + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), # The config of normalization layers. + act_cfg=dict(type='SiLU', inplace=True)), # The config of activation function + neck=dict( + type='YOLOv5PAFPN', # The neck of detector is YOLOv5FPN, We also support 'YOLOv6RepPAFPN', 'YOLOXPAFPN'. + deepen_factor=deepen_factor, # The scaling factor that controls the depth of the network structure + widen_factor=widen_factor, # The scaling factor that controls the width of the network structure + in_channels=[256, 512, 1024], # The input channels, this is consistent with the output channels of backbone + out_channels=[256, 512, 1024], # The output channels of each level of the pyramid feature map, this is consistent with the input channels of head + num_csp_blocks=3, # The number of bottlenecks of CSPLayer + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), # The config of normalization layers. + act_cfg=dict(type='SiLU', inplace=True)), # The config of activation function + bbox_head=dict( + type='YOLOv5Head', # The type of BBox head is 'YOLOv5Head', we also support 'YOLOv6Head', 'YOLOXHead' + head_module=dict( + type='YOLOv5HeadModule', # The type of Head module is 'YOLOv5HeadModule', we also support 'YOLOv6HeadModule', 'YOLOXHeadModule' + num_classes=80, # Number of classes for classification + in_channels=[256, 512, 1024], # The input channels, this is consistent with the input channels of neck + widen_factor=widen_factor, # The scaling factor that controls the width of the network structure + featmap_strides=[8, 16, 32], # The strides of the multi-scale feature maps + num_base_priors=3), # The number of prior boxes on a certain point + prior_generator=dict( # The config of prior generator + type='mmdet.YOLOAnchorGenerator', # The prior generator uses 'YOLOAnchorGenerator. Refer to https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/task_modules/prior_generators/anchor_generator.py for more details + base_sizes=anchors, # Basic scale of the anchor + strides=strides), # The strides of the anchor generator. This is consistent with the FPN feature strides. The strides will be taken as base_sizes if base_sizes is not set. + ), + test_cfg=dict( + multi_label=True, # The config of multi-label for multi-clas prediction. The default setting is True. + nms_pre=30000, # The number of boxes before NMS + score_thr=0.001, # Threshold to filter out boxes. + nms=dict(type='nms', # Type of NMS + iou_threshold=0.65), # NMS threshold + max_per_img=300)) # Max number of detections of each image +``` + +### Dataset and evaluator config + +[Dataloaders](https://pytorch.org/docs/stable/data.html?highlight=data%20loader#torch.utils.data.DataLoader) are required for the training, validation, and testing of the [runner](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html). Dataset and data pipeline need to be set to build the dataloader. Due to the complexity of this part, we use intermediate variables to simplify the writing of dataloader configs. More complex data augmentation methods are adopted for the lightweight object detection algorithms in MMYOLO. Therefore, MMYOLO has a wider range of dataset configurations than other models in MMDetection. + +The training and testing data flow of YOLOv5 have a certain difference. We will introduce them separately here. + +```python +dataset_type = 'CocoDataset' # Dataset type, this will be used to define the dataset +data_root = 'data/coco/' # Root path of data + +pre_transform = [ # Training data loading pipeline + dict( + type='LoadImageFromFile'), # First pipeline to load images from file path + dict(type='LoadAnnotations', # Second pipeline to load annotations for current image + with_bbox=True) # Whether to use bounding box, True for detection +] + +albu_train_transforms = [ # Albumentation is introduced for image data augmentation. We follow the code of YOLOv5-v6.1, please make sure its version is 1.0.+ + dict(type='Blur', p=0.01), # Blur augmentation, the probability is 0.01 + dict(type='MedianBlur', p=0.01), # Median blue augmentation, the probability is 0.01 + dict(type='ToGray', p=0.01), # Randomly convert RGB to gray-scale image, the probability is 0.01 + dict(type='CLAHE', p=0.01) # CLAHE(Limited Contrast Adaptive Histogram Equalization) augmentation, the probability is 0.01 +] +train_pipeline = [ # Training data processing pipeline + *pre_transform, # Introduce the pre-defined training data loading processing + dict( + type='Mosaic', # Mosaic augmentation + img_scale=img_scale, # The image scale after Mosaic augmentation + pad_val=114.0, # Pixel values filled with empty areas + pre_transform=pre_transform), # Pre-defined training data loading pipeline + dict( + type='YOLOv5RandomAffine', # Random Affine augmentation for YOLOv5 + max_rotate_degree=0.0, # Maximum degrees of rotation transform + max_shear_degree=0.0, # Maximum degrees of shear transform + scaling_ratio_range=(0.5, 1.5), # Minimum and maximum ratio of scaling transform + border=(-img_scale[0] // 2, -img_scale[1] // 2), # Distance from height and width sides of input image to adjust output shape. Only used in mosaic dataset. + border_val=(114, 114, 114)), # Border padding values of 3 channels. + dict( + type='mmdet.Albu', # Albumentation of MMDetection + transforms=albu_train_transforms, # Pre-defined albu_train_transforms + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), # Random augmentation on HSV channel + dict(type='mmdet.RandomFlip', prob=0.5), # Random flip, the probability is 0.5 + dict( + type='mmdet.PackDetInputs', # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +train_dataloader = dict( # Train dataloader config + batch_size=train_batch_size_pre_gpu, # Batch size of a single GPU during training + num_workers=train_num_workers, # Worker to pre-fetch data for each single GPU during training + persistent_workers=True, # If ``True``, the dataloader will not shut down the worker processes after an epoch end, which can accelerate training speed. + pin_memory=True, # If ``True``, the dataloader will allow pinned memory, which can reduce copy time between CPU and memory + sampler=dict( # training data sampler + type='DefaultSampler', # DefaultSampler which supports both distributed and non-distributed training. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/dataset/sampler.py + shuffle=True), # randomly shuffle the training data in each epoch + dataset=dict( # Train dataset config + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', # Path of annotation file + data_prefix=dict(img='train2017/'), # Prefix of image path + filter_cfg=dict(filter_empty_gt=False, min_size=32), # Config of filtering images and annotations + pipeline=train_pipeline)) +``` + +In the testing phase of YOLOv5, the [Letter Resize](https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/datasets/transforms/transforms.py#L116) method resizes all the test images to the same scale, which preserves the aspect ratio of all testing images. Therefore, the validation and testing phases share the same data pipeline. + +```python +test_pipeline = [ # Validation/ Testing dataloader config + dict( + type='LoadImageFromFile'), # First pipeline to load images from file path + dict(type='YOLOv5KeepRatioResize', # Second pipeline to resize images with the same aspect ratio + scale=img_scale), # Pipeline that resizes the images + dict( + type='LetterResize', # Third pipeline to rescale images to meet the requirements of different strides + scale=img_scale, # Target scale of image + allow_scale_up=False, # Allow scale up when radio > 1 + pad_val=dict(img=114)), # Padding value + dict(type='LoadAnnotations', with_bbox=True), # Forth pipeline to load annotations for current image + dict( + type='mmdet.PackDetInputs', # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +val_dataloader = dict( + batch_size=val_batch_size_pre_gpu, # Batch size of a single GPU + num_workers=val_num_workers, # Worker to pre-fetch data for each single GPU + persistent_workers=True, # If ``True``, the dataloader will not shut down the worker processes after an epoch end, which can accelerate training speed. + pin_memory=True, # If ``True``, the dataloader will allow pinned memory, which can reduce copy time between CPU and memory + drop_last=False, # IF ``True``, the dataloader will drop data, which fails to make a batch + sampler=dict( + type='DefaultSampler', # Default sampler for both distributed and normal training + shuffle=False), # not shuffle during validation and testing + dataset=dict( + type=dataset_type, + data_root=data_root, + test_mode=True, # # Turn on test mode of the dataset to avoid filtering annotations or images + data_prefix=dict(img='val2017/'), # Prefix of image path + ann_file='annotations/instances_val2017.json', # Path of annotation file + pipeline=test_pipeline, + batch_shapes_cfg=dict( # Config of batch shapes + type='BatchShapePolicy', # Policy that makes paddings with least pixels during batch inference process, which does not require the image scales of all batches to be the same throughout validation. + batch_size=val_batch_size_pre_gpu, # Batch size for batch shapes strategy, equals to validation batch size on single GPU + img_size=img_scale[0], # Image scale + size_divisor=32, # The image scale of padding should be divided by pad_size_divisor + extra_pad_ratio=0.5))) # additional paddings for pixel scale + +test_dataloader = val_dataloader +``` + +[Evaluators](https://mmengine.readthedocs.io/en/latest/design/evaluation.html) are used to compute the metrics of the trained model on the validation and testing datasets. The config of evaluators consists of one or a list of metric configs: + +```python +val_evaluator = dict( # Validation evaluator config + type='mmdet.CocoMetric', # The coco metric used to evaluate AR, AP, and mAP for detection + proposal_nums=(100, 1, 10), # The number of proposal used to evaluate for detection + ann_file=data_root + 'annotations/instances_val2017.json', # Annotation file path + metric='bbox', # Metrics to be evaluated, `bbox` for detection +) +test_evaluator = val_evaluator # Testing evaluator config +``` + +Since the test dataset has no annotation files, the test_dataloader and test_evaluator config in MMYOLO are generally the same as the val's. If you want to save the detection results on the test dataset, you can write the config like this: + +```python +# inference on test dataset and +# format the output results for submission. +test_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=data_root + 'annotations/image_info_test-dev2017.json', + data_prefix=dict(img='test2017/'), + test_mode=True, + pipeline=test_pipeline)) +test_evaluator = dict( + type='mmdet.CocoMetric', + ann_file=data_root + 'annotations/image_info_test-dev2017.json', + metric='bbox', + format_only=True, # Only format and save the results to coco json file + outfile_prefix='./work_dirs/coco_detection/test') # The prefix of output json files +``` + +### Training and testing config + +MMEngine's runner uses Loop to control the training, validation, and testing processes. +Users can set the maximum training epochs and validation intervals with these fields. + +```python +max_epochs = 300 # Maximum training epochs: 300 epochs +save_epoch_intervals = 10 # Validation intervals. Run validation every 10 epochs. + +train_cfg = dict( + type='EpochBasedTrainLoop', # The training loop type. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py + max_epochs=max_epochs, # Maximum training epochs: 300 epochs + val_interval=save_epoch_intervals) # Validation intervals. Run validation every 10 epochs. +val_cfg = dict(type='ValLoop') # The validation loop type +test_cfg = dict(type='TestLoop') # The testing loop type +``` + +MMEngine also supports dynamic intervals for evaluation. For example, you can run validation every 10 epochs on the first 280 epochs, and run validation every epoch on the final 20 epochs. The configurations are as follows. + +```python +max_epochs = 300 # Maximum training epochs: 300 epochs +save_epoch_intervals = 10 # Validation intervals. Run validation every 10 epochs. + +train_cfg = dict( + type='EpochBasedTrainLoop', # The training loop type. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py + max_epochs=max_epochs, # Maximum training epochs: 300 epochs + val_interval=save_epoch_intervals, # Validation intervals. Run validation every 10 epochs. + dynamic_intervals=[(280, 1)]) # Switch evaluation on 280 epoch and switch the interval to 1. +val_cfg = dict(type='ValLoop') # The validation loop type +test_cfg = dict(type='TestLoop') # The testing loop type +``` + +### Optimization config + +`optim_wrapper` is the field to configure optimization-related settings. The optimizer wrapper not only provides the functions of the optimizer but also supports functions such as gradient clipping, mixed precision training, etc. Find out more in the [optimizer wrapper tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html). + +```python +optim_wrapper = dict( # Optimizer wrapper config + type='OptimWrapper', # Optimizer wrapper type, switch to AmpOptimWrapper to enable mixed precision training. + optimizer=dict( # Optimizer config. Support all kinds of optimizers in PyTorch. Refer to https://pytorch.org/docs/stable/optim.html#algorithms + type='SGD', # Stochastic gradient descent optimizer + lr=0.01, # The base learning rate + momentum=0.937, # Stochastic gradient descent with momentum + weight_decay=0.0005, # Weight decay of SGD + nesterov=True, # Enable Nesterov momentum, Refer to http://www.cs.toronto.edu/~hinton/absps/momentum.pdf + batch_size_pre_gpu=train_batch_size_pre_gpu), # Enable automatic learning rate scaling + clip_grad=None, # Gradient clip option. Set None to disable gradient clip. Find usage in https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html + constructor='YOLOv5OptimizerConstructor') # The constructor for YOLOv5 optimizer +``` + +`param_scheduler` is the field that configures methods of adjusting optimization hyperparameters such as learning rate and momentum. Users can combine multiple schedulers to create a desired parameter adjustment strategy. Find more in the [parameter scheduler tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/param_scheduler.html). In YOLOv5, parameter scheduling is complex to implement and difficult to implement with `param_scheduler`. So we use `YOLOv5ParamSchedulerHook` to implement it (see next section), which is simpler but less versatile. + +```python +param_scheduler = None +``` + +### Hook config + +Users can attach hooks to training, validation, and testing loops to insert some operations during running. There are two different hook fields, one is `default_hooks` and the other is `custom_hooks`. + +`default_hooks` is a dict of hook configs for the hooks that must be required at the runtime. They have default priority which should not be modified. If not set, the runner will use the default values. To disable a default hook, users can set its config to `None`. + +```python +default_hooks = dict( + param_scheduler=dict( + type='YOLOv5ParamSchedulerHook', # MMYOLO uses `YOLOv5ParamSchedulerHook` to adjust hyper-parameters in optimizers + scheduler_type='linear', + lr_factor=0.01, + max_epochs=max_epochs), + checkpoint=dict( + type='CheckpointHook', # Hook to save model checkpoint on specific intervals + interval=save_epoch_intervals, # Save model checkpoint every 10 epochs. + max_keep_ckpts=3)) # The maximum checkpoints to keep. +``` + +`custom_hooks` is a list of hook configs. Users can develop their hooks and insert them in this field. + +```python +custom_hooks = [ + dict( + type='EMAHook', # A Hook to apply Exponential Moving Average (EMA) on the model during training. + ema_type='ExpMomentumEMA', # The type of EMA strategy to use. + momentum=0.0001, # The momentum of EMA + update_buffers=True, # # If ``True``, calculate the running averages of model parameters + priority=49) # Priority higher than NORMAL(50) +] +``` + +### Runtime config + +```python +default_scope = 'mmyolo' # The default registry scope to find modules. Refer to https://mmengine.readthedocs.io/en/latest/tutorials/registry.html + +env_cfg = dict( + cudnn_benchmark=True, # Whether to enable cudnn benchmark + mp_cfg=dict( # Multi-processing config + mp_start_method='fork', # Use fork to start multi-processing threads. 'fork' is usually faster than 'spawn' but may be unsafe. See discussion in https://github.com/pytorch/pytorch/issues/1355 + opencv_num_threads=0), # Disable opencv multi-threads to avoid system being overloaded + dist_cfg=dict(backend='nccl'), # Distribution configs +) + +vis_backends = [dict(type='LocalVisBackend')] # Visualization backends. Refer to: https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html +visualizer = dict( + type='mmdet.DetLocalVisualizer', vis_backends=vis_backends, name='visualizer') +log_processor = dict( + type='LogProcessor', # Log processor to process runtime logs + window_size=50, # Smooth interval of log values + by_epoch=True) # Whether to format logs with epoch style. Should be consistent with the train loop's type. + +log_level = 'INFO' # The level of logging. +load_from = None # Load model checkpoint as a pre-trained model from a given path. This will not resume training. +resume = False # Whether to resume from the checkpoint defined in `load_from`. If `load_from` is None, it will resume the latest checkpoint in the `work_dir`. +``` + +## Config file inheritance + +`config/_base_` contains default runtime. The configs that are composed of components from `_base_` are called _primitive_. + +For all configs under the same folder, it is recommended to have only **one** _primitive_ config. All other configs should be inherited from the _primitive_ config. In this way, the maximum inheritance level is 3. + +For easy understanding, we recommend contributors inherit from existing methods. +For example, if some modification is made based on YOLOv5-s, such as modifying the depth of the network, users may first inherit the `_base_ = ./yolov5_s-v61_syncbn_8xb16-300e_coco.py `, then modify the necessary fields in the config files. + +If you are building an entirely new method that does not share the structure with any of the existing methods, you may create a folder `yolov100` under `configs`, + +Please refer to the [mmengine config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) for more details. + +By setting the `_base_` field, we can set which files the current configuration file inherits from. + +When `_base_` is a string of a file path, it means inheriting the contents of one config file. + +```python +_base_ = '../_base_/default_runtime.py' +``` + +When `_base_` is a list of multiple file paths, it means inheriting multiple files. + +```python +_base_ = [ + './yolov5_s-v61_syncbn_8xb16-300e_coco.py', + '../_base_/default_runtime.py' +] +``` + +If you wish to inspect the config file, you may run `mim run mmdet print_config /PATH/TO/CONFIG` to see the complete config. + +### Ignore some fields in the base configs + +Sometimes, you may set `_delete_=True` to ignore some of the fields in base configs. +You may refer to the [mmengine config tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/config.html) for a simple illustration. + +In MMYOLO, for example, to change the backbone of RTMDet with the following config. + +```python +model = dict( + type='YOLODetector', + data_preprocessor=dict(...), + backbone=dict( + type='CSPNeXt', + arch='P5', + expand_ratio=0.5, + deepen_factor=deepen_factor, + widen_factor=widen_factor, + channel_attention=True, + norm_cfg=dict(type='BN'), + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict(...), + bbox_head=dict(...)) +``` + +If you want to change `CSPNeXt` to `YOLOv6EfficientRep` for the RTMDet backbone, because there are different fields (`channel_attention` and `expand_ratio`) in `CSPNeXt` and `YOLOv6EfficientRep`, you need to use `_delete_=True` to replace all the old keys in the `backbone` field with the new keys. + +```python +_base_ = '../rtmdet/rtmdet_l_syncbn_8xb32-300e_coco.py' +model = dict( + backbone=dict( + _delete_=True, + type='YOLOv6EfficientRep', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True)), + neck=dict(...), + bbox_head=dict(...)) +``` + +### Use intermediate variables in configs + +Some intermediate variables are used in the configs files, like `train_pipeline` and `test_pipeline` in datasets. It's worth noting that when modifying intermediate variables in the children configs, users need to pass the intermediate variables into corresponding fields again. +For example, we would like to change the `image_scale` during training and add `YOLOv5MixUp` data augmentation, `img_scale/train_pipeline/test_pipeline` are intermediate variables we would like to modify. + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +img_scale = (1280, 1280) # image height, image width +affine_scale = 0.9 + +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +train_pipeline = [ + *pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', # MixUp augmentation of YOLOv5 + prob=0.1, # the probability of YOLOv5MixUp + pre_transform=[*pre_transform,*mosaic_affine_pipeline]), # Pre-defined Training data pipeline and MixUp augmentation. + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] + +test_pipeline = [ + dict( + type='LoadImageFromFile'), + dict(type='YOLOv5KeepRatioResize', scale=img_scale), + dict( + type='LetterResize', + scale=img_scale, + allow_scale_up=False, + pad_val=dict(img=114)), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'pad_param')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +``` + +We first define a new `train_pipeline`/`test_pipeline` and pass it into `data`. + +Likewise, if we want to switch from `SyncBN` to `BN` or `MMSyncBN`, we need to modify every `norm_cfg` in the configuration file. + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +norm_cfg = dict(type='BN', requires_grad=True) +model = dict( + backbone=dict(norm_cfg=norm_cfg), + neck=dict(norm_cfg=norm_cfg), + ...) +``` + +### Reuse variables in \_base\_ file + +If the users want to reuse the variables in the base file, they can get a copy of the corresponding variable by using `{{_base_.xxx}}`. The latest version of MMEngine also supports reusing variables without `{{}}` usage. + +E.g: + +```python +_base_ = '../_base_/default_runtime.py' + +pre_transform = _base_.pre_transform # `pre_transform` equals to `pre_transform` in the _base_ config +``` + +## Modify config through script arguments + +When submitting jobs using `tools/train.py` or `tools/test.py`, you may specify `--cfg-options` to in-place modify the config. + +- Update config keys of dict chains. + + The config options can be specified following the order of the dict keys in the original config. + For example, `--cfg-options model.backbone.norm_eval=False` changes the all BN modules in model backbones to `train` mode. + +- Update keys inside a list of configs. + + Some config dicts are composed as a list in your config. For example, the training pipeline `train_dataloader.dataset.pipeline` is normally a list, e.g. `[dict(type='LoadImageFromFile'), ...]`. If you want to change `'LoadImageFromFile'` to `'LoadImageFromNDArray'` in the pipeline, you may specify `--cfg-options data.train.pipeline.0.type=LoadImageFromNDArray`. + +- Update values of list/tuples. + + Sometimes the value to update is a list or a tuple, for example, the config file normally sets `model.data_preprocessor.mean=[123.675, 116.28, 103.53]`. If you want to change the mean values, you may specify `--cfg-options model.data_preprocessor.mean="[127,127,127]"`. Note that the quotation mark `"` is necessary to support list/tuple data types, and that **NO** white space is allowed inside the quotation marks in the specified value. + +## Config name style + +We follow the below style to name config files. Contributors are advised to follow the same style. + +``` +{algorithm name}_{model component names [component1]_[component2]_[...]}-[version id]_[norm setting]_[data preprocessor type]_{training settings}_{training dataset information}_[testing dataset information].py +``` + +The file name is divided into 8 name fields, which have 4 required parts and 4 optional parts. All parts and components are connected with `_` and words of each part or component should be connected with `-`. `{}` indicates the required name field, and `[]` indicates the optional name field. + +- `{algorithm name}`: The name of the algorithm. It can be a detector name such as `yolov5`, `yolov6`, `yolox`, etc. +- `{component names}`: Names of the components used in the algorithm such as backbone, neck, etc. For example, `yolov5_s` means its `deepen_factor` is `0.33` and its `widen_factor` is `0.5`. +- `[version_id]` (optional): Since the evolution of the YOLO series is much faster than traditional object detection algorithms, `version id` is used to distinguish the differences between different sub-versions. E.g, YOLOv5-3.0 uses the `Focus` layer as the stem layer, and YOLOv5-6.0 uses the `Conv` layer as the stem layer. +- `[norm_setting]` (optional): `bn` indicates `Batch Normalization`, `syncbn` indicates `Synchronized Batch Normalization`。 +- `[data preprocessor type]` (optional): `fast` incorporates [YOLOv5DetDataPreprocessor](https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/models/data_preprocessors/data_preprocessor.py#L9) and [yolov5_collate](https://github.com/open-mmlab/mmyolo/blob/main/mmyolo/datasets/utils.py#L12) to preprocess data. The training speed is faster than the default `mmdet.DetDataPreprocessor`, while results in extending the overall pipeline to multi-task learning. +- `{training settings}`: Information of training settings such as batch size, augmentations, loss trick, scheduler, and epochs/iterations. For example: `8xb16-300e_coco` means using 8-GPUs x 16-images-per-GPU, and train 300 epochs. + Some abbreviations: + - `{gpu x batch_per_gpu}`: GPUs and samples per GPU. For example, `4xb4` is the short term of 4-GPUs x 4-images-per-GPU. + - `{schedule}`: training schedule, default option in MMYOLO is 300 epochs. +- `{training dataset information}`: Training dataset names like `coco`, `cityscapes`, `voc-0712`, `wider-face`, and `balloon`. +- `[testing dataset information]` (optional): Testing dataset name for models trained on one dataset but tested on another. If not mentioned, it means the model was trained and tested on the same dataset type. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/custom_installation.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/custom_installation.md new file mode 100644 index 0000000000000000000000000000000000000000..604a77a305c590ffb598d582208732b136f99cf3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/custom_installation.md @@ -0,0 +1,109 @@ +# Customize Installation + +## CUDA versions + +When installing PyTorch, you need to specify the version of CUDA. If you are not clear on which to choose, follow our recommendations: + +- For Ampere-based NVIDIA GPUs, such as GeForce 30 series and NVIDIA A100, CUDA 11 is a must. +- For older NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 offers better compatibility and is more lightweight. + +Please make sure the GPU driver satisfies the minimum version requirements. See [this table](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions) for more information. + +```{note} +Installing CUDA runtime libraries is enough if you follow our best practices, because no CUDA code will be compiled locally. However, if you hope to compile MMCV from source or develop other CUDA operators, you need to install the complete CUDA toolkit from NVIDIA's [website](https://developer.nvidia.com/cuda-downloads), and its version should match the CUDA version of PyTorch. i.e., the specified version of cudatoolkit in `conda install` command. +``` + +## Install MMEngine without MIM + +To install MMEngine with pip instead of MIM, please follow \[MMEngine installation guides\](https://mmengine.readthedocs.io/en/latest/get_started/installation.html). + +For example, you can install MMEngine by the following command. + +```shell +pip install "mmengine>=0.6.0" +``` + +## Install MMCV without MIM + +MMCV contains C++ and CUDA extensions, thus depending on PyTorch in a complex way. MIM solves such dependencies automatically and makes the installation easier. However, it is not a must. + +To install MMCV with pip instead of MIM, please follow [MMCV installation guides](https://mmcv.readthedocs.io/en/2.x/get_started/installation.html). This requires manually specifying a find-url based on the PyTorch version and its CUDA version. + +For example, the following command installs MMCV built for PyTorch 1.12.x and CUDA 11.6. + +```shell +pip install "mmcv>=2.0.0rc4" -f https://download.openmmlab.com/mmcv/dist/cu116/torch1.12.0/index.html +``` + +## Install on CPU-only platforms + +MMDetection can be built for the CPU-only environment. In CPU mode you can train (requires MMCV version >= `2.0.0rc1`), test, or infer a model. + +However, some functionalities are gone in this mode: + +- Deformable Convolution +- Modulated Deformable Convolution +- ROI pooling +- Deformable ROI pooling +- CARAFE +- SyncBatchNorm +- CrissCrossAttention +- MaskedConv2d +- Temporal Interlace Shift +- nms_cuda +- sigmoid_focal_loss_cuda +- bbox_overlaps + +If you try to train/test/infer a model containing the above ops, an error will be raised. +The following table lists affected algorithms. + +| Operator | Model | +| :-----------------------------------------------------: | :--------------------------------------------------------------------------------------: | +| Deformable Convolution/Modulated Deformable Convolution | DCN、Guided Anchoring、RepPoints、CentripetalNet、VFNet、CascadeRPN、NAS-FCOS、DetectoRS | +| MaskedConv2d | Guided Anchoring | +| CARAFE | CARAFE | +| SyncBatchNorm | ResNeSt | + +## Install on Google Colab + +[Google Colab](https://research.google.com/) usually has PyTorch installed, +thus we only need to install MMEngine, MMCV, MMDetection, and MMYOLO with the following commands. + +**Step 1.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim). + +```shell +!pip3 install openmim +!mim install "mmengine>=0.6.0" +!mim install "mmcv>=2.0.0rc4,<2.1.0" +!mim install "mmdet>=3.0.0,<4.0.0" +``` + +**Step 2.** Install MMYOLO from the source. + +```shell +!git clone https://github.com/open-mmlab/mmyolo.git +%cd mmyolo +!pip install -e . +``` + +**Step 3.** Verification. + +```python +import mmyolo +print(mmyolo.__version__) +# Example output: 0.1.0, or an another version. +``` + +```{note} +Within Jupyter, the exclamation mark `!` is used to call external executables and `%cd` is a [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) to change the current working directory of Python. +``` + +## Develop using multiple MMYOLO versions + +The training and testing scripts have been modified in `PYTHONPATH` to ensure that the scripts use MMYOLO in the current directory. + +To have the default MMYOLO installed in your environment instead of what is currently in use, you can remove the code that appears in the relevant script: + +```shell +PYTHONPATH="$(dirname $0)/..":$PYTHONPATH +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/data_flow.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/data_flow.md new file mode 100644 index 0000000000000000000000000000000000000000..ab0e2e64a6a47592e8109d468bb8e9109cc08073 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/data_flow.md @@ -0,0 +1,121 @@ +# Mixed image data augmentation update + +Mixed image data augmentation is similar to Mosaic and MixUp, in which the annotation information of multiple images needs to be obtained for fusion during the running process. In the OpenMMLab data augmentation pipeline, other indexes of the dataset are generally not available. In order to achieve the above function, in the YOLOX reproduced in MMDetection, the concept of [MultiImageMixDataset](https://github.com/open-mmlab/mmdetection/blob/master/mmdet/datasets/dataset_wrappers.py#L338) dataset wrapper is proposed. + +`MultiImageMixDataset` dataset wrapper will include some data augmentation methods such as `Mosaic` and `RandAffine`, while `CocoDataset` will also need to include a `pipeline` to achieve the image and annotation loading function. In this way, we can achieve mixed data augmentation quickly. The configuration method is as follows: + +```python +train_pipeline = [ + dict(type='Mosaic', img_scale=img_scale, pad_val=114.0), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0), + ... +] +train_dataset = dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type='CocoDataset', + pipeline=[ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True) + ]), + pipeline=train_pipeline) + +``` + +However, this implementation has a disadvantage: users unfamiliar with MMDetection will forget those data augmentation methods like Mosaic must be used together with `MultiImageMixDataset`, increasing the usage complexity. Moreover, it is hard to understand as well. + +To address this problem, further simplifications are made in MMYOLO, which directly lets `pipeline` get `dataset`. In this way, the implementation of `Mosaic` and other data augmentation methods can be achieved and used just as the random flip, without a data wrapper anymore. The new configuration method is as follows: + +```python +pre_transform = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True) +] +train_pipeline = [ + *pre_transform, + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='mmdet.RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='YOLOXMixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0, + pre_transform=pre_transform), + ... +] +``` + +A more complex YOLOv5-m configuration including MixUp is shown as follows: + +```python +mosaic_affine_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + pre_transform=pre_transform), + dict( + type='YOLOv5RandomAffine', + max_rotate_degree=0.0, + max_shear_degree=0.0, + scaling_ratio_range=(1 - affine_scale, 1 + affine_scale), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + border_val=(114, 114, 114)) +] + +# enable mixup +train_pipeline = [ + *pre_transform, *mosaic_affine_pipeline, + dict( + type='YOLOv5MixUp', + prob=0.1, + pre_transform=[*pre_transform, *mosaic_affine_pipeline]), + dict( + type='mmdet.Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags']), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }), + dict(type='YOLOv5HSVRandomAug'), + dict(type='mmdet.RandomFlip', prob=0.5), + dict( + type='mmdet.PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +``` + +It is very easy to use, just pass the object of Dataset to the pipeline. + +```python +def prepare_data(self, idx) -> Any: + """Pass the dataset to the pipeline during training to support mixed + data augmentation, such as Mosaic and MixUp.""" + if self.test_mode is False: + data_info = self.get_data_info(idx) + data_info['dataset'] = self + return self.pipeline(data_info) + else: + return super().prepare_data(idx) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/faq.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/faq.md new file mode 100644 index 0000000000000000000000000000000000000000..ca2a0b25fa54a928df81ce7214625d7cd7df4977 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/faq.md @@ -0,0 +1,101 @@ +# Frequently Asked Questions + +We list some common problems many users face and their corresponding solutions here. Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them. If the contents here do not cover your issue, please create an [issue](https://github.com/open-mmlab/mmyolo/issues/new/choose) and make sure you fill in all the required information in the template. + +## Why do we need to launch MMYOLO? + +Why do we need to launch MMYOLO? Why do we need to open a separate repository instead of putting it directly into MMDetection? Since the open source, we have been receiving similar questions from our community partners, and the answers can be summarized in the following three points. + +**(1) Unified operation and inference platform** + +At present, there are very many improved algorithms for YOLO in the field of target detection, and they are very popular, but such algorithms are based on different frameworks for different back-end implementations, and there are significant differences, lacking a unified and convenient fair evaluation process from training to deployment. + +**(2) Protocol limitations** + +As we all know, YOLOv5 and its derived algorithms, such as YOLOv6 and YOLOv7 are GPL 3.0 protocols, which differ from the Apache protocol of MMDetection. Therefore, due to the protocol issue, it is not possible to incorporate MMYOLO directly into MMDetection. + +**(3) Multitasking support** + +There is another far-reaching reason: **MMYOLO tasks are not limited to MMDetection**, and more tasks will be supported in the future, such as MMPose based keypoint-related applications and MMTracking based tracking related applications, so it is not suitable to be directly incorporated into MMDetection. + +## What is the projects folder used for? + +The `projects` folder is newly introduced in OpenMMLab 2.0. There are three primary purposes: + +1. facilitate community contributors: Since OpenMMLab series codebases have a rigorous code management process, this inevitably leads to long algorithm reproduction cycles, which is not friendly to community contributions. +2. facilitate rapid support for new algorithms: A long development cycle can also lead to another problem users may not be able to experience the latest algorithms as soon as possible. +3. facilitate rapid support for new approaches and features: New approaches or new features may be incompatible with the current design of the codebases and cannot be quickly incorporated. + +In summary, the `projects` folder solves the problems of slow support for new algorithms and complicated support for new features due to the long algorithm reproduction cycle. Each folder in `projects` is an entirely independent project, and community users can quickly support some algorithms in the current version through `projects`. This allows the community to quickly use new algorithms and features that are difficult to adapt in the current version. When the design is stable or the code meets the merge specification, it will be considered to merge into the main branch. + +## Why does the performance drop significantly by switching the YOLOv5 backbone to Swin? + +In [Replace the backbone network](../recommended_topics/replace_backbone.md), we provide many tutorials on replacing the backbone module. However, you may not get a desired result once you replace the module and start directly training the model. This is because different networks have very distinct hyperparameters. Take the backbones of Swin and YOLOv5 as an example. Swin belongs to the transformer family, and the YOLOv5 is a convolutional network. Their training optimizers, learning rates, and other hyperparameters are different. If we force using Swin as the backbone of YOLOv5 and try to get a moderate performance, we must modify many parameters. + +## How to use the components implemented in all MM series repositories? + +In OpenMMLab 2.0, we have enhanced the ability to use different modules across MM series libraries. Currently, users can call any module that has been registered in MM series algorithm libraries via `MM Algorithm Library A. Module Name`. We demonstrated using MMClassification backbones in the [Replace the backbone network](../recommended_topics/replace_backbone.md). Other modules can be used in the same way. + +## Can pure background pictures be added in MMYOLO for training? + +Adding pure background images to training can suppress the false positive rate in most scenarios, and this feature has already been supported for most datasets. Take `YOLOv5CocoDataset` as an example. The control parameter is `train_dataloader.dataset.filter_cfg.filter_empty_gt`. If `filter_empty_gt` is True, the pure background images will be filtered out and not used in training, and vice versa. Most of the algorithms in MMYOLO have added this feature by default. + +## Is there a script to calculate the inference FPS in MMYOLO? + +MMYOLO is based on MMDet 3.x, which provides a [benchmark script](https://github.com/open-mmlab/mmdetection/blob/3.x/tools/analysis_tools/benchmark.py) to calculate the inference FPS. We recommend using `mim` to run the script in MMDet directly across the library instead of copying them to MMYOLO. More details about `mim` usages can be found at [Use mim to run scripts from other OpenMMLab repositories](../common_usage/mim_usage.md). + +## What is the difference between MMDeploy and EasyDeploy? + +MMDeploy is developed and maintained by the OpenMMLab deployment team to provide model deployment solutions for the OpenMMLab series algorithms, which support various inference backends and customization features. EasyDeploy is an easier and more lightweight deployment project provided by the community. However, it does not support as many features as MMDeploy. Users can choose which one to use in MMYOLO according to their needs. + +## How to check the AP of every category in COCOMetric? + +Just set `test_evaluator.classwise` to True or add `--cfg-options test_evaluator.classwise=True` when running the test script. + +## Why doesn't MMYOLO support the auto-learning rate scaling feature as MMDet? + +It is because the YOLO series algorithms are not very well suited for linear scaling. We have verified on several datasets that the performance is better without the auto-scaling based on batch size. + +## Why is the weight size of my trained model larger than the official one? + +The reason is that user-trained weights usually include extra data such as `optimizer`, `ema_state_dict`, and `message_hub`, which are removed when we publish the models. While on the contrary, the weight users trained by themselves are kept. You can use the [publish_model.py](https://github.com/open-mmlab/mmyolo/blob/main/tools/misc/publish_model.py) to remove these unnecessary components. + +## Why does the RTMDet cost more graphics memory during the training than YOLOv5? + +It is due to the assigner in RTMDet. YOLOv5 uses a simple and efficient shape-matching assigner, while RTMDet uses a dynamic soft label assigner for entire batch computation. Therefore, it consumes more memory in its internal cost matrix, especially when there are too many labeled bboxes in the current batch. We are considering solving this problem soon. + +## Do I need to reinstall MMYOLO after modifying some code? + +Without adding any new python code, and if you installed the MMYOLO by `mim install -v -e .`, any new modifications will take effect without reinstalling. However, if you add new python codes and are using them, you need to reinstall with `mim install -v -e .`. + +## How to use multiple versions of MMYOLO to develop? + +If users have multiple versions of the MMYOLO, such as mmyolo-v1 and mmyolo-v2. They can specify the target version of their MMYOLO by using this command in the shell: + +```shell +PYTHONPATH="$(dirname $0)/..":$PYTHONPATH +``` + +Users can unset the `PYTHONPATH` when they want to reset to the default MMYOLO by this command: + +```shell +unset PYTHONPATH +``` + +## How to save the best checkpoints during the training? + +Users can choose what metrics to filter the best models by setting the `default_hooks.checkpoint.save_best` in the configuration. Take the COCO dataset detection task as an example. Users can customize the `default_hooks.checkpoint.save_best` with these parameters: + +1. `auto` works based on the first evaluation metric in the validation set. +2. `coco/bbox_mAP` works based on `bbox_mAP`. +3. `coco/bbox_mAP_50` works based on `bbox_mAP_50`. +4. `coco/bbox_mAP_75` works based on `bbox_mAP_75`. +5. `coco/bbox_mAP_s` works based on `bbox_mAP_s`. +6. `coco/bbox_mAP_m` works based on `bbox_mAP_m`. +7. `coco/bbox_mAP_l` works based on `bbox_mAP_l`. + +In addition, users can also choose the filtering logic by setting `default_hooks.checkpoint.rule` in the configuration. For example, `default_hooks.checkpoint.rule=greater` means that the larger the indicator is, the better it is. More details can be found at [checkpoint_hook](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py). + +## How to train and test with non-square input sizes? + +The default configurations of the YOLO series algorithms are mostly squares like 640x640 or 1280x1280. However, if users want to train with a non-square shape, they can modify the `image_scale` to the desired value in the configuration. A more detailed example could be found at [yolov5_s-v61_fast_1xb12-40e_608x352_cat.py](https://github.com/open-mmlab/mmyolo/tree/dev/configs/yolov5/yolov5_s-v61_fast_1xb12-40e_608x352_cat.py). diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/rotated_detection.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/rotated_detection.md new file mode 100644 index 0000000000000000000000000000000000000000..c0addb015f92b9f98926eacfcc82192b3a9c63ac --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/rotated_detection.md @@ -0,0 +1,3 @@ +# Rotated Object Detection + +TODO diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/warning_notes.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/warning_notes.md new file mode 100644 index 0000000000000000000000000000000000000000..791cd9d4bbf6d5f20a36d9f00a88097cfabde5e7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/tutorials/warning_notes.md @@ -0,0 +1,24 @@ +# Common Warning Notes + +The purpose of this document is to collect warning messages that users often find confusing, and provide explanations to facilitate understanding. + +## xxx registry in mmyolo did not set import location + +The warning message complete information is that The xxx registry in mmyolo did not set import location. Fallback to call `mmyolo.utils.register_all_modules` instead. + +This warning means that a module was not set with an import location when importing it, making it impossible to determine its location. Therefore, `mmyolo.utils.register_all_modules` is automatically called to trigger the package import. +This warning belongs to the very low-level module warning in MMEngine, which may be difficult for users to understand, but it has no impact on the actual use and can be ignored directly. + +## save_param_schedulers is true but self.param_schedulers is None + +The following information is an example using the YOLOv5 algorithm. This is because the parameter scheduler strategy `YOLOv5ParamSchedulerHook` has been rewritten in YOLOv5, so the ParamScheduler designed in MMEngine is not used. However, `save_param_schedulers` is not set to False in the YOLOv5 configuration. + +First of all, this warning has no impact on performance and resuming training. If users think this warning affects experience, you can set `default_hooks.checkpoint.save_param_scheduler` to False, or set `--cfg-options default_hooks.checkpoint.save_param_scheduler=False` when training via the command line. + +## The loss_cls will be 0. This is a normal phenomenon. + +This is related to specific algorithms. Taking YOLOv5 as an example, its classification loss only considers positive samples. If the number of classes is 1, then the classification loss and object loss are functionally redundant. Therefore, in the design, when the number of classes is 1, the loss_cls is not calculated and is always 0. This is a normal phenomenon. + +## The model and loaded state dict do not match exactly + +Whether this warning will affect performance needs to be determined based on more information. If it occurs during fine-tuning, it is a normal phenomenon that the COCO pre-trained weights of the Head module cannot be loaded due to the user's custom class differences, and it will not affect performance. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/browse_coco_json.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/browse_coco_json.md new file mode 100644 index 0000000000000000000000000000000000000000..772b8a56ff143676a0c05249203d3bffb3f33527 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/browse_coco_json.md @@ -0,0 +1,62 @@ +# Visualize COCO labels + +`tools/analysis_tools/browse_coco_json.py` is a script that can visualization to display the COCO label in the picture. + +```shell +python tools/analysis_tools/browse_coco_json.py [--data-root ${DATA_ROOT}] \ + [--img-dir ${IMG_DIR}] \ + [--ann-file ${ANN_FILE}] \ + [--wait-time ${WAIT_TIME}] \ + [--disp-all] [--category-names CATEGORY_NAMES [CATEGORY_NAMES ...]] \ + [--shuffle] +``` + +If images and labels are in the same folder, you can specify `--data-root` to the folder, and then `--img-dir` and `--ann-file` to specify the relative path of the folder. The code will be automatically spliced. +If the image and label files are not in the same folder, you do not need to specify `--data-root`, but directly specify `--img-dir` and `--ann-file` of the absolute path. + +E.g: + +1. Visualize all categories of `COCO` and display all types of annotations such as `bbox` and `mask`: + +```shell +python tools/analysis_tools/browse_coco_json.py --data-root './data/coco' \ + --img-dir 'train2017' \ + --ann-file 'annotations/instances_train2017.json' \ + --disp-all +``` + +If images and labels are not in the same folder, you can use a absolutely path: + +```shell +python tools/analysis_tools/browse_coco_json.py --img-dir '/dataset/image/coco/train2017' \ + --ann-file '/label/instances_train2017.json' \ + --disp-all +``` + +2. Visualize all categories of `COCO`, and display only the `bbox` type labels, and shuffle the image to show: + +```shell +python tools/analysis_tools/browse_coco_json.py --data-root './data/coco' \ + --img-dir 'train2017' \ + --ann-file 'annotations/instances_train2017.json' \ + --shuffle +``` + +3. Only visualize the `bicycle` and `person` categories of `COCO` and only the `bbox` type labels are displayed: + +```shell +python tools/analysis_tools/browse_coco_json.py --data-root './data/coco' \ + --img-dir 'train2017' \ + --ann-file 'annotations/instances_train2017.json' \ + --category-names 'bicycle' 'person' +``` + +4. Visualize all categories of `COCO`, and display all types of label such as `bbox`, `mask`, and shuffle the image to show: + +```shell +python tools/analysis_tools/browse_coco_json.py --data-root './data/coco' \ + --img-dir 'train2017' \ + --ann-file 'annotations/instances_train2017.json' \ + --disp-all \ + --shuffle +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/browse_dataset.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/browse_dataset.md new file mode 100644 index 0000000000000000000000000000000000000000..f066d22545f9896f6c60ab4cf3303b7137b26629 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/browse_dataset.md @@ -0,0 +1,42 @@ +# Visualize Datasets + +`tools/analysis_tools/browse_dataset.py` helps the user to browse a detection dataset (both images and bounding box annotations) visually, or save the image to a designated directory. + +```shell +python tools/analysis_tools/browse_dataset.py ${CONFIG} \ + [--out-dir ${OUT_DIR}] \ + [--not-show] \ + [--show-interval ${SHOW_INTERVAL}] +``` + +E,g： + +1. Use `config` file `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py` to visualize the picture. The picture will pop up directly and be saved to the directory `work_dirs/browse_ dataset` at the same time: + +```shell +python tools/analysis_tools/browse_dataset.py 'configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' \ + --out-dir 'work_dirs/browse_dataset' +``` + +2. Use `config` file `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py` to visualize the picture. The picture will pop up and display directly. Each picture lasts for `10` seconds. At the same time, it will be saved to the directory `work_dirs/browse_ dataset`: + +```shell +python tools/analysis_tools/browse_dataset.py 'configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' \ + --out-dir 'work_dirs/browse_dataset' \ + --show-interval 10 +``` + +3. Use `config` file `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py` to visualize the picture. The picture will pop up and display directly. Each picture lasts for `10` seconds and the picture will not be saved: + +```shell +python tools/analysis_tools/browse_dataset.py 'configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' \ + --show-interval 10 +``` + +4. Use `config` file `configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py` to visualize the picture. The picture will not pop up directly, but only saved to the directory `work_dirs/browse_ dataset`: + +```shell +python tools/analysis_tools/browse_dataset.py 'configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py' \ + --out-dir 'work_dirs/browse_dataset' \ + --not-show +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/dataset_analysis.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/dataset_analysis.md new file mode 100644 index 0000000000000000000000000000000000000000..c6149e9435f92a911daafe3ce2ba963d6bd4619b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/dataset_analysis.md @@ -0,0 +1,79 @@ +# Visualize dataset analysis + +`tools/analysis_tools/dataset_analysis.py` help users get the renderings of the four functions, and save the pictures to the `dataset_analysis` folder under the current running directory. + +Description of the script's functions: + +The data required by each sub function is obtained through the data preparation of `main()`. + +Function 1: Generated by the sub function `show_bbox_num` to display the distribution of categories and bbox instances. + + + +Function 2: Generated by the sub function `show_bbox_wh` to display the width and height distribution of categories and bbox instances. + + + +Function 3: Generated by the sub function `show_bbox_wh_ratio` to display the width to height ratio distribution of categories and bbox instances. + + + +Function 3: Generated by the sub function `show_bbox_area` to display the distribution map of category and bbox instance area based on area rules. + + + +Print List: Generated by the sub function `show_class_list` and `show_data_list`. + + + +```shell +python tools/analysis_tools/dataset_analysis.py ${CONFIG} \ + [--type ${TYPE}] \ + [--class-name ${CLASS_NAME}] \ + [--area-rule ${AREA_RULE}] \ + [--func ${FUNC}] \ + [--out-dir ${OUT_DIR}] +``` + +E,g： + +1.Use `config` file `configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py` analyze the dataset, By default,the data loading type is `train_dataset`, the area rule is `[0,32,96,1e5]`, generate a result graph containing all functions and save the graph to the current running directory `./dataset_analysis` folder: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py +``` + +2.Use `config` file `configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py` analyze the dataset, change the data loading type from the default `train_dataset` to `val_dataset` through the `--val-dataset` setting: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py \ + --val-dataset +``` + +3.Use `config` file `configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py` analyze the dataset, change the display of all generated classes to specific classes. Take the display of `person` classes as an example: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py \ + --class-name person +``` + +4.Use `config` file `configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py` analyze the dataset, redefine the area rule through `--area-rule` . Take `30 70 125` as an example, the area rule becomes `[0,30,70,125,1e5]`： + +```shell +python tools/analysis_tools/dataset_analysis.py configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py \ + --area-rule 30 70 125 +``` + +5.Use `config` file `configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py` analyze the dataset, change the display of four function renderings to only display `Function 1` as an example: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py \ + --func show_bbox_num +``` + +6.Use `config` file `configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py` analyze the dataset, modify the picture saving address to `work_dirs/dataset_analysis`: + +```shell +python tools/analysis_tools/dataset_analysis.py configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py \ + --out-dir work_dirs/dataset_analysis +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/dataset_converters.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/dataset_converters.md new file mode 100644 index 0000000000000000000000000000000000000000..72ad968c14a0c4a8445b8fa57772903b823faa10 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/dataset_converters.md @@ -0,0 +1,55 @@ +# Dataset Conversion + +The folder `tools/data_converters` currently contains `ballon2coco.py`, `yolo2coco.py`, and `labelme2coco.py` - three dataset conversion tools. + +- `ballon2coco.py` converts the `balloon` dataset (this small dataset is for starters only) to COCO format. + +```shell +python tools/dataset_converters/balloon2coco.py +``` + +- `yolo2coco.py` converts a dataset from `yolo-style` **.txt** format to COCO format, please use it as follows: + +```shell +python tools/dataset_converters/yolo2coco.py /path/to/the/root/dir/of/your_dataset +``` + +Instructions: + +1. `image_dir` is the root directory of the yolo-style dataset you need to pass to the script, which should contain `images`, `labels`, and `classes.txt`. `classes.txt` is the class declaration corresponding to the current dataset. One class a line. The structure of the root directory should be formatted as this example shows: + +```bash +. +└── $ROOT_PATH + ├── classes.txt + ├── labels + │ ├── a.txt + │ ├── b.txt + │ └── ... + ├── images + │ ├── a.jpg + │ ├── b.png + │ └── ... + └── ... +``` + +2. The script will automatically check if `train.txt`, `val.txt`, and `test.txt` have already existed under `image_dir`. If these files are located, the script will organize the dataset accordingly. Otherwise, the script will convert the dataset into one file. The image paths in these files must be **ABSOLUTE** paths. +3. By default, the script will create a folder called `annotations` in the `image_dir` directory which stores the converted JSON file. If `train.txt`, `val.txt`, and `test.txt` are not found, the output file is `result.json`. Otherwise, the corresponding JSON file will be generated, named as `train.json`, `val.json`, and `test.json`. The `annotations` folder may look similar to this: + +```bash +. +└── $ROOT_PATH + ├── annotations + │ ├── result.json + │ └── ... + ├── classes.txt + ├── labels + │ ├── a.txt + │ ├── b.txt + │ └── ... + ├── images + │ ├── a.jpg + │ ├── b.png + │ └── ... + └── ... +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/download_dataset.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/download_dataset.md new file mode 100644 index 0000000000000000000000000000000000000000..8a3e57ec6d14036813ccc7c9e586b99f939126d1 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/download_dataset.md @@ -0,0 +1,11 @@ +# Download Dataset + +`tools/misc/download_dataset.py` supports downloading datasets such as `COCO`, `VOC`, `LVIS` and `Balloon`. + +```shell +python tools/misc/download_dataset.py --dataset-name coco2017 +python tools/misc/download_dataset.py --dataset-name voc2007 +python tools/misc/download_dataset.py --dataset-name voc2012 +python tools/misc/download_dataset.py --dataset-name lvis +python tools/misc/download_dataset.py --dataset-name balloon [--save-dir ${SAVE_DIR}] [--unzip] +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/extract_subcoco.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/extract_subcoco.md new file mode 100644 index 0000000000000000000000000000000000000000..b2c7e06cf36c9b56d4aa91ec128601ef39674abc --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/extract_subcoco.md @@ -0,0 +1,60 @@ +# Extracts a subset of COCO + +The training dataset of the COCO2017 dataset includes 118K images, and the validation set includes 5K images, which is a relatively large dataset. Loading JSON in debugging or quick verification scenarios will consume more resources and bring slower startup speed. + +The `extract_subcoco.py` script provides the ability to extract a specified number/classes/area-size of images. The user can use the `--num-img`, `--classes`, `--area-size` parameter to get a COCO subset of the specified condition of images. + +For example, extract images use scripts as follows: + +```shell +python tools/misc/extract_subcoco.py \ + ${ROOT} \ + ${OUT_DIR} \ + --num-img 20 \ + --classes cat dog person \ + --area-size small +``` + +It gone be extract 20 images, and only includes annotations which belongs to cat(or dog/person) and bbox area size is small, after filter by class and area size, the empty annotation images won't be chosen, guarantee the images be extracted definitely has annotation info. + +Currently, only support COCO2017. In the future will support user-defined datasets of standard coco JSON format. + +The root path folder format is as follows: + +```text +├── root +│ ├── annotations +│ ├── train2017 +│ ├── val2017 +│ ├── test2017 +``` + +1. Extract 10 training images and 10 validation images using only 5K validation sets. + +```shell +python tools/misc/extract_subcoco.py ${ROOT} ${OUT_DIR} --num-img 10 +``` + +2. Extract 20 training images using the training set and 20 validation images using the validation set. + +```shell +python tools/misc/extract_subcoco.py ${ROOT} ${OUT_DIR} --num-img 20 --use-training-set +``` + +3. Set the global seed to 1. The default is no setting. + +```shell +python tools/misc/extract_subcoco.py ${ROOT} ${OUT_DIR} --num-img 20 --use-training-set --seed 1 +``` + +4. Extract images by specify classes + +```shell +python tools/misc/extract_subcoco.py ${ROOT} ${OUT_DIR} --classes cat dog person +``` + +5. Extract images by specify anchor size + +```shell +python tools/misc/extract_subcoco.py ${ROOT} ${OUT_DIR} --area-size small +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/log_analysis.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/log_analysis.md new file mode 100644 index 0000000000000000000000000000000000000000..c45170aaaadb97855c51e67819df52ce3868a141 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/log_analysis.md @@ -0,0 +1,82 @@ +# Log Analysis + +## Curve plotting + +`tools/analysis_tools/analyze_logs.py` in MMDetection plots loss/mAP curves given a training log file. Run `pip install seaborn` first to install the dependency. + +```shell +mim run mmdet analyze_logs plot_curve \ + ${LOG} \ # path of train log in json format + [--keys ${KEYS}] \ # the metric that you want to plot, default to 'bbox_mAP' + [--start-epoch ${START_EPOCH}] # the epoch that you want to start, default to 1 + [--eval-interval ${EVALUATION_INTERVAL}] \ # the evaluation interval when training, default to 1 + [--title ${TITLE}] \ # title of figure + [--legend ${LEGEND}] \ # legend of each plot, default to None + [--backend ${BACKEND}] \ # backend of plt, default to None + [--style ${STYLE}] \ # style of plt, default to 'dark' + [--out ${OUT_FILE}] # the path of output file +# [] stands for optional parameters, when actually entering the command line, you do not need to enter [] +``` + +Examples: + +- Plot the classification loss of some run. + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + --keys loss_cls \ + --legend loss_cls + ``` + + + +- Plot the classification and regression loss of some run, and save the figure to a pdf. + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + --keys loss_cls loss_bbox \ + --legend loss_cls loss_bbox \ + --out losses_yolov5_s.pdf + ``` + + + +- Compare the bbox mAP of two runs in the same figure. + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739.log.json \ + --keys bbox_mAP \ + --legend yolov5_s yolov5_n \ + --eval-interval 10 # Note that the evaluation interval must be the same as during training. Otherwise, it will raise an error. + ``` + + + +## Compute the average training speed + +```shell +mim run mmdet analyze_logs cal_train_time \ + ${LOG} \ # path of train log in json format + [--include-outliers] # include the first value of every epoch when computing the average time +``` + +Examples: + +```shell +mim run mmdet analyze_logs cal_train_time \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json +``` + +The output is expected to be like the following. + +```text +-----Analyze train time of yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json----- +slowest epoch 278, average time is 0.1705 s/iter +fastest epoch 300, average time is 0.1510 s/iter +time std over epochs is 0.0026 +average iter time: 0.1556 s/iter +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/model_converters.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/model_converters.md new file mode 100644 index 0000000000000000000000000000000000000000..09fb52df13c2861f691672d7fe1d27e69af5d0e3 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/model_converters.md @@ -0,0 +1,54 @@ +# Convert Model + +The six scripts under the `tools/model_converters` directory can help users convert the keys in the official pre-trained model of YOLO to the format of MMYOLO, and use MMYOLO to fine-tune the model. + +## YOLOv5 + +Take conversion `yolov5s.pt` as an example: + +1. Clone the official YOLOv5 code to the local (currently the maximum supported version is `v6.1`): + +```shell +git clone -b v6.1 https://github.com/ultralytics/yolov5.git +cd yolov5 +``` + +2. Download official weight file: + +```shell +wget https://github.com/ultralytics/yolov5/releases/download/v6.1/yolov5s.pt +``` + +3. Copy file `tools/model_converters/yolov5_to_mmyolo.py` to the path of YOLOv5 official code clone: + +```shell +cp ${MMDET_YOLO_PATH}/tools/model_converters/yolov5_to_mmyolo.py yolov5_to_mmyolo.py +``` + +4. Conversion + +```shell +python yolov5_to_mmyolo.py --src ${WEIGHT_FILE_PATH} --dst mmyolov5.pt +``` + +The converted `mmyolov5.pt` can be used by MMYOLO. The official weight conversion of YOLOv6 is also used in the same way. + +## YOLOX + +The conversion of YOLOX model **does not need** to download the official YOLOX code, just download the weight. + +Take conversion `yolox_s.pth` as an example: + +1. Download official weight file: + +```shell +wget https://github.com/Megvii-BaseDetection/YOLOX/releases/download/0.1.1rc0/yolox_s.pth +``` + +2. Conversion + +```shell +python tools/model_converters/yolox_to_mmyolo.py --src yolox_s.pth --dst mmyolox.pt +``` + +The converted `mmyolox.pt` can be used by MMYOLO. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/optimize_anchors.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/optimize_anchors.md new file mode 100644 index 0000000000000000000000000000000000000000..460bc6e2fa3f4bec41b39901f1e66c442802911c --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/optimize_anchors.md @@ -0,0 +1,38 @@ +# Optimize anchors size + +Script `tools/analysis_tools/optimize_anchors.py` supports three methods to optimize YOLO anchors including `k-means` +anchor cluster, `Differential Evolution` and `v5-k-means`. + +## k-means + +In k-means method, the distance criteria is based IoU, python shell as follow: + +```shell +python tools/analysis_tools/optimize_anchors.py ${CONFIG} \ + --algorithm k-means \ + --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} \ + --out-dir ${OUT_DIR} +``` + +## Differential Evolution + +In differential_evolution method, based differential evolution algorithm, use `avg_iou_cost` as minimum target function, python shell as follow: + +```shell +python tools/analysis_tools/optimize_anchors.py ${CONFIG} \ + --algorithm DE \ + --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} \ + --out-dir ${OUT_DIR} +``` + +## v5-k-means + +In v5-k-means method, clustering standard as same with YOLOv5 which use shape-match, python shell as follow: + +```shell +python tools/analysis_tools/optimize_anchors.py ${CONFIG} \ + --algorithm v5-k-means \ + --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} \ + --prior_match_thr ${PRIOR_MATCH_THR} \ + --out-dir ${OUT_DIR} +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/print_config.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/print_config.md new file mode 100644 index 0000000000000000000000000000000000000000..2a6ee79f36c749491a1b5095792b708755fca279 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/print_config.md @@ -0,0 +1,20 @@ +# Print the whole config + +`print_config.py` in MMDetection prints the whole config verbatim, expanding all its imports. The command is as following. + +```shell +mim run mmdet print_config \ + ${CONFIG} \ # path of the config file + [--save-path] \ # save path of whole config, suffixed with .py, .json or .yml + [--cfg-options ${OPTIONS [OPTIONS...]}] # override some settings in the used config +``` + +Examples: + +```shell +mim run mmdet print_config \ + configs/yolov5/yolov5_s-v61_syncbn_fast_1xb4-300e_balloon.py \ + --save-path ./work_dirs/yolov5_s-v61_syncbn_fast_1xb4-300e_balloon.py +``` + +Running the above command will save the `yolov5_s-v61_syncbn_fast_1xb4-300e_balloon.py` config file with the inheritance relationship expanded to \`\`yolov5_s-v61_syncbn_fast_1xb4-300e_balloon_whole.py`in the`./work_dirs\` folder. diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/vis_scheduler.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/vis_scheduler.md new file mode 100644 index 0000000000000000000000000000000000000000..f1526342c9ee80236f7c146231430818811e2a82 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/en/useful_tools/vis_scheduler.md @@ -0,0 +1,44 @@ +# Hyper-parameter Scheduler Visualization + +`tools/analysis_tools/vis_scheduler` aims to help the user to check the hyper-parameter scheduler of the optimizer(without training), which support the "learning rate", "momentum", and "weight_decay". + +```bash +python tools/analysis_tools/vis_scheduler.py \ + ${CONFIG_FILE} \ + [-p, --parameter ${PARAMETER_NAME}] \ + [-d, --dataset-size ${DATASET_SIZE}] \ + [-n, --ngpus ${NUM_GPUs}] \ + [-o, --out-dir ${OUT_DIR}] \ + [--title ${TITLE}] \ + [--style ${STYLE}] \ + [--window-size ${WINDOW_SIZE}] \ + [--cfg-options] +``` + +**Description of all arguments**： + +- `config`: The path of a model config file. +- **`-p, --parameter`**: The param to visualize its change curve, choose from "lr", "momentum" or "wd". Default to use "lr". +- **`-d, --dataset-size`**: The size of the datasets. If set，`DATASETS.build` will be skipped and `${DATASET_SIZE}` will be used as the size. Default to use the function `DATASETS.build`. +- **`-n, --ngpus`**: The number of GPUs used in training, default to be 1. +- **`-o, --out-dir`**: The output path of the curve plot, default not to output. +- `--title`: Title of figure. If not set, default to be config file name. +- `--style`: Style of plt. If not set, default to be `whitegrid`. +- `--window-size`: The shape of the display window. If not specified, it will be set to `12*7`. If used, it must be in the format `'W*H'`. +- `--cfg-options`: Modifications to the configuration file, refer to [Learn about Configs](../tutorials/config.md). + +```{note} +Loading annotations maybe consume much time, you can directly specify the size of the dataset with `-d, dataset-size` to save time. +``` + +You can use the following command to plot the step learning rate schedule used in the config `configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py`: + +```shell +python tools/analysis_tools/vis_scheduler.py \ + configs/rtmdet/rtmdet_s_syncbn_fast_8xb32-300e_coco.py \ + --dataset-size 118287 \ + --ngpus 8 \ + --out-dir ./output +``` + +
diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/Makefile b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..d4bb2cbb9eddb1bb1b4f366623044af8e4830919 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/_static/css/readthedocs.css b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/_static/css/readthedocs.css new file mode 100644 index 0000000000000000000000000000000000000000..353aa9e285a5639b0f34ecb3b16115cff1ad25ed --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/_static/css/readthedocs.css @@ -0,0 +1,6 @@ +.header-logo { + background-image: url("../image/mmyolo-logo.png"); + background-size: 115px 40px; + height: 40px; + width: 115px; +} diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/_static/image/mmyolo-logo.png b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/_static/image/mmyolo-logo.png new file mode 100644 index 0000000000000000000000000000000000000000..7be9707ff3a1675a0344cc31e1a41805dc810bfb --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/_static/image/mmyolo-logo.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0f8e8c432c88108f3f8905667027f4f4a676727348ed6ca0f49c46baebf0d66 +size 30145 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/advanced_guides/cross-library_application.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/advanced_guides/cross-library_application.md new file mode 100644 index 0000000000000000000000000000000000000000..d95f68cd22cdfc6218c24c7c02936f7fb04fd247 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/advanced_guides/cross-library_application.md @@ -0,0 +1 @@ +# MMYOLO 跨库应用解析 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/api.rst b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/api.rst new file mode 100644 index 0000000000000000000000000000000000000000..39223a34f849b4b66dafea7fe9c9fdd34d06ecfe --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/api.rst @@ -0,0 +1,80 @@ +mmyolo.datasets +-------------------- + +datasets +^^^^^^^^^^ +.. automodule:: mmyolo.datasets + :members: + +transforms +^^^^^^^^^^^^ +.. automodule:: mmyolo.datasets.transforms + :members: + +mmyolo.engine +-------------- + +hooks +^^^^^^^^^^ +.. automodule:: mmyolo.engine.hooks + :members: + +optimizers +^^^^^^^^^^ +.. automodule:: mmyolo.engine.optimizers + :members: + +mmyolo.models +-------------- + +backbones +^^^^^^^^^^ +.. automodule:: mmyolo.models.backbones + :members: + +data_preprocessor +^^^^^^^^^^^^^^^^^^^ +.. automodule:: mmyolo.models.data_preprocessor + :members: + +dense_heads +^^^^^^^^^^^^ +.. automodule:: mmyolo.models.dense_heads + :members: + +detectors +^^^^^^^^^^ +.. automodule:: mmyolo.models.detectors + :members: + +layers +^^^^^^^^^^ +.. automodule:: mmyolo.models.layers + :members: + +losses +^^^^^^^^^^ +.. automodule:: mmyolo.models.losses + :members: + +necks +^^^^^^^^^^^^ +.. automodule:: mmyolo.models.necks + :members: + + +task_modules +^^^^^^^^^^^^^^^ +.. automodule:: mmyolo.models.task_modules + :members: + +utils +^^^^^^^^^^ +.. automodule:: mmyolo.models.utils + :members: + + +mmyolo.utils +-------------- +.. automodule:: mmyolo.utils + :members: diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/amp_training.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/amp_training.md new file mode 100644 index 0000000000000000000000000000000000000000..c7803abfea4487734b05de80705689d30c796e1a --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/amp_training.md @@ -0,0 +1,13 @@ +# 自动混合精度（AMP）训练 + +如果要开启自动混合精度（AMP）训练，在训练命令最后加上 `--amp` 即可， 命令如下： + +```shell +python tools/train.py python ./tools/train.py ${CONFIG} --amp +``` + +具体例子如下： + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py --amp +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/freeze_layers.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/freeze_layers.md new file mode 100644 index 0000000000000000000000000000000000000000..ca0613903b65a6b2ba6986b3dea2830ee4465a2b --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/freeze_layers.md @@ -0,0 +1,28 @@ +# 冻结指定网络层权重 + +## 冻结 backbone 权重 + +在 MMYOLO 中我们可以通过设置 `frozen_stages` 参数去冻结主干网络的部分 `stage`, 使这些 `stage` 的参数不参与模型的更新。 +需要注意的是：`frozen_stages = i` 表示的意思是指从最开始的 `stage` 开始到第 `i` 层 `stage` 的所有参数都会被冻结。下面是 `YOLOv5` 的例子，其他算法也是同样的逻辑： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + backbone=dict( + frozen_stages=1 # 表示第一层 stage 以及它之前的所有 stage 中的参数都会被冻结 + )) +``` + +## 冻结 neck 权重 + +MMYOLO 中也可以通过参数 `freeze_all` 去冻结整个 `neck` 的参数。下面是 `YOLOv5` 的例子，其他算法也是同样的逻辑： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + neck=dict( + freeze_all=True # freeze_all=True 时表示整个 neck 的参数都会被冻结 + )) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/mim_usage.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/mim_usage.md new file mode 100644 index 0000000000000000000000000000000000000000..aaf26920e15e0856c2f0fcb0a7fdd845766c44b7 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/mim_usage.md @@ -0,0 +1,89 @@ +# 使用 mim 跨库调用其他 OpenMMLab 仓库的脚本 + +```{note} +1. 目前暂不支持跨库调用所有脚本，正在修复中。等修复完成，本文档会添加更多的例子。 +2. 绘制 mAP 和 计算平均训练速度 两项功能在 MMDetection dev-3.x 分支中修复，目前需要通过源码安装该分支才能成功调用。 +``` + +## 日志分析 + +### 曲线图绘制 + +MMDetection 中的 `tools/analysis_tools/analyze_logs.py` 可利用指定的训练 log 文件绘制 loss/mAP 曲线图， 第一次运行前请先运行 `pip install seaborn` 安装必要依赖。 + +```shell +mim run mmdet analyze_logs plot_curve \ + ${LOG} \ # 日志文件路径 + [--keys ${KEYS}] \ # 需要绘制的指标，默认为 'bbox_mAP' + [--start-epoch ${START_EPOCH}] # 起始的 epoch，默认为 1 + [--eval-interval ${EVALUATION_INTERVAL}] \ # 评估间隔，默认为 1 + [--title ${TITLE}] \ # 图片标题，无默认值 + [--legend ${LEGEND}] \ # 图例，默认为 None + [--backend ${BACKEND}] \ # 绘制后端，默认为 None + [--style ${STYLE}] \ # 绘制风格，默认为 'dark' + [--out ${OUT_FILE}] # 输出文件路径 +# [] 代表可选参数，实际输入命令行时，不用输入 [] +``` + +样例： + +- 绘制分类损失曲线图 + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + --keys loss_cls \ + --legend loss_cls + ``` + + + +- 绘制分类损失、回归损失曲线图，保存图片为对应的 pdf 文件 + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + --keys loss_cls loss_bbox \ + --legend loss_cls loss_bbox \ + --out losses_yolov5_s.pdf + ``` + + + +- 在同一图像中比较两次运行结果的 bbox mAP + + ```shell + mim run mmdet analyze_logs plot_curve \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json \ + yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739.log.json \ + --keys bbox_mAP \ + --legend yolov5_s yolov5_n \ + --eval-interval 10 # 注意评估间隔必须和训练时设置的一致，否则会报错 + ``` + + + +### 计算平均训练速度 + +```shell +mim run mmdet analyze_logs cal_train_time \ + ${LOG} \ # 日志文件路径 + [--include-outliers] # 计算时包含每个 epoch 的第一个数据 +``` + +样例： + +```shell +mim run mmdet analyze_logs cal_train_time \ + yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json +``` + +输出以如下形式展示： + +```text +-----Analyze train time of yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json----- +slowest epoch 278, average time is 0.1705 s/iter +fastest epoch 300, average time is 0.1510 s/iter +time std over epochs is 0.0026 +average iter time: 0.1556 s/iter +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/module_combination.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/module_combination.md new file mode 100644 index 0000000000000000000000000000000000000000..011836f68fb9b35434d7e823c382ce5357dd2f9f --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/module_combination.md @@ -0,0 +1,280 @@ +# 算法组合替换教程 + +## Loss 组合替换教程 + +OpenMMLab 2.0 体系中 MMYOLO、MMDetection、MMClassification 中的 loss 注册表都继承自 MMEngine 中的根注册表。 因此用户可以在 MMYOLO 中使用来自 MMDetection、MMClassification 中实现的 loss 而无需重新实现。 + +### 替换 YOLOv5 Head 中的 loss_cls 函数 + +1. 假设我们想使用 `LabelSmoothLoss` 作为 `loss_cls` 的损失函数。因为 `LabelSmoothLoss` 已经在 MMClassification 中实现了，所以可以直接在配置文件中进行替换。配置文件如下： + +```python +# 请先使用命令： mim install "mmcls>=1.0.0rc2"，安装 mmcls +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model = dict( + bbox_head=dict( + loss_cls=dict( + _delete_=True, + _scope_='mmcls', # 临时替换 scope 为 mmcls + type='LabelSmoothLoss', + label_smooth_val=0.1, + mode='multi_label', + reduction='mean', + loss_weight=0.5))) +``` + +2. 假设我们想使用 `VarifocalLoss` 作为 `loss_cls` 的损失函数。因为 `VarifocalLoss` 在 MMDetection 已经实现好了，所以可以直接替换。配置文件如下： + +```python +model = dict( + bbox_head=dict( + loss_cls=dict( + _delete_=True, + _scope_='mmdet', + type='VarifocalLoss', + loss_weight=1.0))) +``` + +3. 假设我们想使用 `FocalLoss` 作为 `loss_cls` 的损失函数。配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model = dict( + bbox_head=dict( + loss_cls= dict( + _delete_=True, + _scope_='mmdet', + type='FocalLoss', + loss_weight=1.0))) +``` + +4. 假设我们想使用 `QualityFocalLoss` 作为 `loss_cls` 的损失函数。配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model = dict( + bbox_head=dict( + loss_cls= dict( + _delete_=True, + _scope_='mmdet', + type='QualityFocalLoss', + loss_weight=1.0))) +``` + +### 替换 YOLOv5 Head 中的 loss_obj 函数 + +`loss_obj` 的替换与 `loss_cls` 的替换类似，我们可以使用已经实现好的损失函数对 `loss_obj` 的损失函数进行替换 + +1. 假设我们想使用 `VarifocalLoss` 作为 `loss_obj` 的损失函数 + +```python +model = dict( + bbox_head=dict( + loss_obj=dict( + _delete_=True, + _scope_='mmdet', + type='VarifocalLoss', + loss_weight=1.0))) +``` + +2. 假设我们想使用 `FocalLoss` 作为 `loss_obj` 的损失函数。 + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model = dict( + bbox_head=dict( + loss_cls= dict( + _delete_=True, + _scope_='mmdet', + type='FocalLoss', + loss_weight=1.0))) +``` + +3. 假设我们想使用 `QualityFocalLoss` 作为 `loss_obj` 的损失函数。 + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model = dict( + bbox_head=dict( + loss_cls= dict( + _delete_=True, + _scope_='mmdet', + type='QualityFocalLoss', + loss_weight=1.0))) +``` + +#### 注意 + +1. 在本教程中损失函数的替换是运行不报错的，但无法保证性能一定会上升。 +2. 本次损失函数的替换都是以 YOLOv5 算法作为例子的，但是 MMYOLO 下的多个算法，如 YOLOv6，YOLOX 等算法都可以按照上述的例子进行替换。 + +## Model 和 Loss 组合替换 + +在 MMYOLO 中，model 即网络本身和 loss 是解耦的，用户可以简单的通过修改配置文件中 model 和 loss 来组合不同模块。下面给出两个具体例子。 + +(1) YOLOv5 model 组合 YOLOv7 loss，配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' +model = dict( + bbox_head=dict( + _delete_=True, + type='YOLOv7Head', + head_module=dict( + type='YOLOv5HeadModule', + num_classes=80, + in_channels=[256, 512, 1024], + widen_factor=0.5, + featmap_strides=[8, 16, 32], + num_base_priors=3))) +``` + +(2) RTMDet model 组合 YOLOv6 loss，配置文件如下： + +```python +_base_ = './rtmdet_l_syncbn_8xb32-300e_coco.py' +model = dict( + bbox_head=dict( + _delete_=True, + type='YOLOv6Head', + head_module=dict( + type='RTMDetSepBNHeadModule', + num_classes=80, + in_channels=256, + stacked_convs=2, + feat_channels=256, + norm_cfg=dict(type='BN'), + act_cfg=dict(type='SiLU', inplace=True), + share_conv=True, + pred_kernel_size=1, + featmap_strides=[8, 16, 32]), + loss_bbox=dict( + type='IoULoss', + iou_mode='giou', + bbox_format='xyxy', + reduction='mean', + loss_weight=2.5, + return_iou=False)), + train_cfg=dict( + _delete_=True, + initial_epoch=4, + initial_assigner=dict( + type='BatchATSSAssigner', + num_classes=80, + topk=9, + iou_calculator=dict(type='mmdet.BboxOverlaps2D')), + assigner=dict( + type='BatchTaskAlignedAssigner', + num_classes=80, + topk=13, + alpha=1, + beta=6) + )) +``` + +## Backbone + Neck + HeadModule 的组合替换 + +### 1. YOLOv5 Backbone 替换 + +(1) 假设想将 `RTMDet backbone + yolov5 neck + yolov5 head` 作为 `YOLOv5` 的完整网络，则配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +widen_factor = 0.5 +deepen_factor = 0.33 + +model = dict( + backbone=dict( + _delete_=True, + type='CSPNeXt', + arch='P5', + expand_ratio=0.5, + deepen_factor=deepen_factor, + widen_factor=widen_factor, + channel_attention=True, + norm_cfg=dict(type='BN'), + act_cfg=dict(type='SiLU', inplace=True)) +) +``` + +(2) `YOLOv6EfficientRep backbone + yolov5 neck + yolov5 head` 作为 `YOLOv5` 的完整网络，则配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + backbone=dict( + type='YOLOv6EfficientRep', + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='ReLU', inplace=True)) +) +``` + +### 2. YOLOv5 Neck 替换 + +(1) 假设想将 `yolov5 backbone + yolov6 neck + yolov5 head` 作为 `YOLOv5` 的完整网络，则配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + neck = dict( + type = 'YOLOv6RepPAFPN', + in_channels = [256, 512, 1024], + out_channels = [128, 256, 512], # 注意 YOLOv6RepPAFPN 的输出通道是[128, 256, 512] + num_csp_blocks = 12, + act_cfg = dict(type='ReLU', inplace = True), + ), + bbox_head = dict( + head_module = dict( + in_channels = [128, 256, 512])) # head 部分输入通道要做相应更改 +) +``` + +(2) 假设想将 `yolov5 backbone + yolov7 neck + yolov5 head` 作为 `YOLOv5` 的完整网络，则配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +deepen_factor = _base_.deepen_factor +widen_factor = _base_.widen_factor + +model = dict( + neck = dict( + _delete_=True, # 将 _base_ 中关于 neck 的字段删除 + type = 'YOLOv7PAFPN', + deepen_factor = deepen_factor, + widen_factor = widen_factor, + upsample_feats_cat_first = False, + in_channels = [256, 512, 1024], + out_channels = [128, 256, 512], + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg = dict(type='SiLU', inplace=True), + ), + bbox_head = dict( + head_module = dict( + in_channels = [256, 512, 1024])) # 注意使用 YOLOv7PAFPN 后 head 部分输入通道数是 neck 输出通道数的两倍 +) +``` + +### 3. YOLOv5 HeadModule 替换 + +(1) 假设想将 `yolov5 backbone + yolov5 neck + yolo7 headmodule` 作为 `YOLOv5` 的完整网络，则配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +strides = [8, 16, 32] +num_classes = 1 # 根据自己的数据集调整 + +model = dict( + bbox_head=dict( + type='YOLOv7Head', + head_module=dict( + type='YOLOv7HeadModule', + num_classes=num_classes, + in_channels=[256, 512, 1024], + featmap_strides=strides, + num_base_priors=3))) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/ms_training_testing.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/ms_training_testing.md new file mode 100644 index 0000000000000000000000000000000000000000..1f271c54df6517bb515b4312ee7b921beeb7b6ba --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/ms_training_testing.md @@ -0,0 +1,41 @@ +# 多尺度训练和测试 + +## 多尺度训练 + +MMYOLO 中目前支持了主流的 YOLOv5、YOLOv6、YOLOv7、YOLOv8 和 RTMDet 等算法，其默认配置均为单尺度 640x640 训练。 在 MM 系列开源库中常用的多尺度训练有两种实现方式： + +1. 在 `train_pipeline` 中输出的每张图都是不定尺度的，然后在 [DataPreprocessor](https://github.com/open-mmlab/mmdetection/blob/3.x/mmdet/models/data_preprocessors/data_preprocessor.py) 中将不同尺度的输入图片 + 通过 [stack_batch](https://github.com/open-mmlab/mmengine/blob/dbae83c52fa54d6dda08b6692b124217fe3b2135/mmengine/model/base_model/data_preprocessor.py#L260-L261) 函数填充到同一尺度，从而组成 batch 进行训练。MMDet 中大部分算法都是采用这个实现方式。 +2. 在 `train_pipeline` 中输出的每张图都是固定尺度的，然后直接在 `DataPreprocessor` 中进行 batch 张图片的上下采样，从而实现多尺度训练功能 + +在 MMYOLO 中两种多尺度训练方式都是支持的。理论上第一种实现方式所生成的尺度会更加丰富，但是由于其对单张图进行独立增强，训练效率不如第二种方式。所以我们更推荐使用第二种方式。 + +以 `configs/yolov5/yolov5_s-v61_fast_1xb12-40e_cat.py` 配置为例，其默认配置采用的是 640x640 固定尺度训练，假设想实现以 32 为倍数，且多尺度范围为 (480, 800) 的训练方式，则可以参考 YOLOX 做法通过 DataPreprocessor 中的 [YOLOXBatchSyncRandomResize](https://github.com/open-mmlab/mmyolo/blob/dc85144fab20a970341550794857a2f2f9b11564/mmyolo/models/data_preprocessors/data_preprocessor.py#L20) 实现。 + +在 `configs/yolov5` 路径下新建配置，命名为 `configs/yolov5/yolov5_s-v61_fast_1xb12-ms-40e_cat.py`，其内容如下： + +```python +_base_ = 'yolov5_s-v61_fast_1xb12-40e_cat.py' + +model = dict( + data_preprocessor=dict( + type='YOLOv5DetDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='YOLOXBatchSyncRandomResize', + # 多尺度范围是 480~800 + random_size_range=(480, 800), + # 输出尺度需要被 32 整除 + size_divisor=32, + # 每隔 1 个迭代改变一次输出输出 + interval=1) + ]) +) +``` + +上述配置就可以实现多尺度训练了。为了方便，我们已经在 `configs/yolov5/` 下已经提供了该配置。其余 YOLO 系列算法也是类似做法。 + +## 多尺度测试 + +MMYOLO 多尺度测试功能等同于测试时增强 TTA，目前已经支持，详情请查看 [测试时增强 TTA](./tta.md) 。 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/multi_necks.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/multi_necks.md new file mode 100644 index 0000000000000000000000000000000000000000..a4a17052729205884c6259b2087cd2a51044c7b0 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/multi_necks.md @@ -0,0 +1,40 @@ +# 应用多个 Neck + +如果你想堆叠多个 Neck，可以直接在配置文件中的 Neck 参数，MMYOLO 支持以 `List` 形式拼接多个 Neck 配置，你需要保证上一个 Neck 的输出通道与下一个 Neck +的输入通道相匹配。如需要调整通道，可以插入 `mmdet.ChannelMapper` 模块用来对齐多个 Neck 之间的通道数量。具体配置如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +deepen_factor = _base_.deepen_factor +widen_factor = _base_.widen_factor +model = dict( + type='YOLODetector', + neck=[ + dict( + type='YOLOv5PAFPN', + deepen_factor=deepen_factor, + widen_factor=widen_factor, + in_channels=[256, 512, 1024], + out_channels=[256, 512, 1024], + # 因为 out_channels 由 widen_factor 控制，YOLOv5PAFPN 的 out_channels = out_channels * widen_factor + num_csp_blocks=3, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='SiLU', inplace=True)), + dict( + type='mmdet.ChannelMapper', + in_channels=[128, 256, 512], + out_channels=128, + ), + dict( + type='mmdet.DyHead', + in_channels=128, + out_channels=256, + num_blocks=2, + # disable zero_init_offset to follow official implementation + zero_init_offset=False) + ], + bbox_head=dict(head_module=dict(in_channels=[512, 512, 512])) + # 因为 out_channels 由 widen_factor 控制，YOLOv5HeadModuled 的 in_channels * widen_factor 才会等于最后一个 neck 的 out_channels +) +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/output_predictions.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/output_predictions.md new file mode 100644 index 0000000000000000000000000000000000000000..b11f856d674852582bbac3b50ac1d48148c366b8 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/output_predictions.md @@ -0,0 +1,40 @@ +# 输出模型预测结果 + +如果想将预测结果保存为特定的文件，用于离线评估，目前 MMYOLO 支持 json 和 pkl 两种格式。 + +```{note} +json 文件仅保存 `image_id`、`bbox`、`score` 和 `category_id`； json 文件可以使用 json 库读取。 +pkl 保存内容比 json 文件更多，还会保存预测图片的文件名和尺寸等一系列信息； pkl 文件可以使用 pickle 库读取。 +``` + +## 输出为 json 文件 + +如果想将预测结果输出为 json 文件，则命令如下： + +```shell +python tools/test.py ${CONFIG} ${CHECKPOINT} --json-prefix ${JSON_PREFIX} +``` + +`--json-prefix` 后的参数输入为文件名前缀（无需输入 `.json` 后缀），也可以包含路径。举一个具体例子： + +```shell +python tools/test.py configs\yolov5\yolov5_s-v61_syncbn_8xb16-300e_coco.py yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth --json-prefix work_dirs/demo/json_demo +``` + +运行以上命令会在 `work_dirs/demo` 文件夹下，输出 `json_demo.bbox.json` 文件。 + +## 输出为 pkl 文件 + +如果想将预测结果输出为 pkl 文件，则命令如下： + +```shell +python tools/test.py ${CONFIG} ${CHECKPOINT} --out ${OUTPUT_FILE} [--cfg-options ${OPTIONS [OPTIONS...]}] +``` + +`--out` 后的参数输入为完整文件名（**必须输入** `.pkl` 或 `.pickle` 后缀），也可以包含路径。举一个具体例子： + +```shell +python tools/test.py configs\yolov5\yolov5_s-v61_syncbn_8xb16-300e_coco.py yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth --out work_dirs/demo/pkl_demo.pkl +``` + +运行以上命令会在 `work_dirs/demo` 文件夹下，输出 `pkl_demo.pkl` 文件。 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/plugins.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/plugins.md new file mode 100644 index 0000000000000000000000000000000000000000..337111f9975393bdc4804ebaf64860e40dfa9fc5 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/plugins.md @@ -0,0 +1,34 @@ +# 给主干网络增加插件 + +MMYOLO 支持在 Backbone 的不同 Stage 后增加如 `none_local`、`dropblock` 等插件，用户可以直接通过修改 config 文件中 `backbone` 的 `plugins`参数来实现对插件的管理。例如为 `YOLOv5` 增加`GeneralizedAttention` 插件，其配置文件如下： + +```python +_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py' + +model = dict( + backbone=dict( + plugins=[ + dict( + cfg=dict( + type='GeneralizedAttention', + spatial_range=-1, + num_heads=8, + attention_type='0011', + kv_stride=2), + stages=(False, False, True, True)) + ])) +``` + +`cfg` 参数表示插件的具体配置， `stages` 参数表示是否在 backbone 对应的 stage 后面增加插件，长度需要和 backbone 的 stage 数量相同。 + +目前 `MMYOLO` 支持了如下插件： + +
+支持的插件 + +1. [CBAM](https://github.com/open-mmlab/mmyolo/blob/dev/mmyolo/models/plugins/cbam.py#L86) +2. [GeneralizedAttention](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/bricks/generalized_attention.py#L13) +3. [NonLocal2d](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/bricks/non_local.py#L250) +4. [ContextBlock](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/bricks/context_block.py#L18) + +
diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/registries_info.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/registries_info.md new file mode 100644 index 0000000000000000000000000000000000000000..4a9d184cd56b69262bf3831f0d175ab1ca52eb13 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/registries_info.md @@ -0,0 +1,788 @@ +# MM 系列开源库注册表 + +（注意：本文档是通过 .dev_scripts/print_registers.py 脚本自动生成） + +## MMdetection (3.0.0rc6) + +
MMdetection Module Components
+
+ + + + + + + + + + + + + + + + + + + + +
visualizeroptimizer constructorloopparameter schedulerdata sampler
  • DetLocalVisualizer
  • LearningRateDecayOptimizerConstructor
  • TeacherStudentValLoop
  • QuadraticWarmupParamScheduler
  • QuadraticWarmupLR
  • QuadraticWarmupMomentum
  • AspectRatioBatchSampler
  • ClassAwareSampler
  • MultiSourceSampler
  • GroupMultiSourceSampler
+
+ + + + + + + + + + + + + + + + + + + + +
metrichookdatasettask util (part 1)task util (part 2)
  • CityScapesMetric
  • CocoMetric
  • CocoOccludedSeparatedMetric
  • CocoPanopticMetric
  • CrowdHumanMetric
  • DumpDetResults
  • DumpProposals
  • LVISMetric
  • OpenImagesMetric
  • VOCMetric
  • CheckInvalidLossHook
  • MeanTeacherHook
  • MemoryProfilerHook
  • NumClassCheckHook
  • PipelineSwitchHook
  • SetEpochInfoHook
  • SyncNormHook
  • DetVisualizationHook
  • YOLOXModeSwitchHook
  • FastStopTrainingHook
  • BaseDetDataset
  • CocoDataset
  • CityscapesDataset
  • CocoPanopticDataset
  • CrowdHumanDataset
  • MultiImageMixDataset
  • DeepFashionDataset
  • LVISV05Dataset
  • LVISDataset
  • LVISV1Dataset
  • Objects365V1Dataset
  • Objects365V2Dataset
  • OpenImagesDataset
  • OpenImagesChallengeDataset
  • XMLDataset
  • VOCDataset
  • WIDERFaceDataset
  • MaxIoUAssigner
  • ApproxMaxIoUAssigner
  • ATSSAssigner
  • CenterRegionAssigner
  • DynamicSoftLabelAssigner
  • GridAssigner
  • HungarianAssigner
  • BboxOverlaps2D
  • BBoxL1Cost
  • IoUCost
  • ClassificationCost
  • FocalLossCost
  • DiceCost
  • CrossEntropyLossCost
  • MultiInstanceAssigner
  • PointAssigner
  • AnchorGenerator
  • SSDAnchorGenerator
  • LegacyAnchorGenerator
  • LegacySSDAnchorGenerator
  • YOLOAnchorGenerator
  • PointGenerator
  • MlvlPointGenerator
  • RegionAssigner
  • SimOTAAssigner
  • TaskAlignedAssigner
  • UniformAssigner
  • BucketingBBoxCoder
  • DeltaXYWHBBoxCoder
+
+ + + + + + + + + + + + + + + + + + +
task util (part 3)transform (part 1)transform (part 2)transform (part 3)
  • DistancePointBBoxCoder
  • LegacyDeltaXYWHBBoxCoder
  • PseudoBBoxCoder
  • TBLRBBoxCoder
  • YOLOBBoxCoder
  • CombinedSampler
  • RandomSampler
  • InstanceBalancedPosSampler
  • IoUBalancedNegSampler
  • MaskPseudoSampler
  • MultiInsRandomSampler
  • OHEMSampler
  • PseudoSampler
  • ScoreHLRSampler
  • AutoAugment
  • RandAugment
  • ColorTransform
  • Color
  • Brightness
  • Contrast
  • Sharpness
  • Solarize
  • SolarizeAdd
  • Posterize
  • Equalize
  • AutoContrast
  • Invert
  • PackDetInputs
  • ToTensor
  • ImageToTensor
  • Transpose
  • WrapFieldsToLists
  • GeomTransform
  • ShearX
  • ShearY
  • Rotate
  • TranslateX
  • TranslateY
  • InstaBoost
  • LoadImageFromNDArray
  • LoadMultiChannelImageFromFiles
  • LoadAnnotations
  • LoadPanopticAnnotations
  • LoadProposals
  • FilterAnnotations
  • LoadEmptyAnnotations
  • InferencerLoader
  • Resize
  • FixShapeResize
  • RandomFlip
  • RandomShift
  • Pad
  • RandomCrop
  • SegRescale
  • PhotoMetricDistortion
  • Expand
  • MinIoURandomCrop
  • Corrupt
  • Albu
  • RandomCenterCropPad
  • CutOut
  • Mosaic
  • MixUp
  • RandomAffine
  • YOLOXHSVRandomAug
  • CopyPaste
  • RandomErasing
  • CachedMosaic
  • CachedMixUp
  • MultiBranch
  • RandomOrder
  • ProposalBroadcaster
+
+ + + + + + + + + + + + + + + + + + +
model (part 1)model (part 2)model (part 3)model (part 4)
  • SiLU
  • DropBlock
  • ExpMomentumEMA
  • SinePositionalEncoding
  • LearnedPositionalEncoding
  • DynamicConv
  • MSDeformAttnPixelDecoder
  • Linear
  • NormedLinear
  • NormedConv2d
  • PixelDecoder
  • TransformerEncoderPixelDecoder
  • CSPDarknet
  • CSPNeXt
  • Darknet
  • ResNet
  • ResNetV1d
  • DetectoRS_ResNet
  • DetectoRS_ResNeXt
  • EfficientNet
  • HourglassNet
  • HRNet
  • MobileNetV2
  • PyramidVisionTransformer
  • PyramidVisionTransformerV2
  • ResNeXt
  • RegNet
  • Res2Net
  • ResNeSt
  • BFP
  • ChannelMapper
  • CSPNeXtPAFPN
  • CTResNetNeck
  • DilatedEncoder
  • DyHead
  • FPG
  • FPN
  • FPN_CARAFE
  • HRFPN
  • NASFPN
  • NASFCOS_FPN
  • PAFPN
  • RFP
  • SSDNeck
  • SSH
  • YOLOV3Neck
  • YOLOXPAFPN
  • SSDVGG
  • SwinTransformer
  • TridentResNet
  • DetDataPreprocessor
  • BatchSyncRandomResize
  • BatchFixedSizePad
  • MultiBranchDataPreprocessor
  • BatchResize
  • BoxInstDataPreprocessor
  • AnchorFreeHead
  • AnchorHead
  • ATSSHead
  • FCOSHead
  • AutoAssignHead
  • CondInstBboxHead
  • CondInstMaskHead
  • BoxInstBboxHead
  • BoxInstMaskHead
  • RPNHead
  • StageCascadeRPNHead
  • CascadeRPNHead
  • CenterNetHead
  • CenterNetUpdateHead
  • CornerHead
  • CentripetalHead
  • DETRHead
  • ConditionalDETRHead
  • DABDETRHead
  • DDODHead
  • DeformableDETRHead
  • DINOHead
  • EmbeddingRPNHead
  • FoveaHead
+
+ + + + + + + + + + + + + + + + + + +
model (part 5)model (part 6)model (part 7)model (part 8)
  • RetinaHead
  • FreeAnchorRetinaHead
  • AssociativeEmbeddingLoss
  • BalancedL1Loss
  • CrossEntropyLoss
  • DiceLoss
  • FocalLoss
  • GaussianFocalLoss
  • QualityFocalLoss
  • DistributionFocalLoss
  • GHMC
  • GHMR
  • IoULoss
  • BoundedIoULoss
  • GIoULoss
  • DIoULoss
  • CIoULoss
  • EIoULoss
  • KnowledgeDistillationKLDivLoss
  • MSELoss
  • SeesawLoss
  • SmoothL1Loss
  • L1Loss
  • VarifocalLoss
  • FSAFHead
  • GuidedAnchorHead
  • GARetinaHead
  • GARPNHead
  • GFLHead
  • PAAHead
  • LADHead
  • LDHead
  • MaskFormerHead
  • Mask2FormerHead
  • NASFCOSHead
  • PISARetinaHead
  • SSDHead
  • PISASSDHead
  • RepPointsHead
  • RetinaSepBNHead
  • RTMDetHead
  • RTMDetSepBNHead
  • RTMDetInsHead
  • RTMDetInsSepBNHead
  • SABLRetinaHead
  • SOLOHead
  • DecoupledSOLOHead
  • DecoupledSOLOLightHead
  • SOLOV2Head
  • TOODHead
  • VFNetHead
  • YOLACTHead
  • YOLACTProtonet
  • YOLOV3Head
  • YOLOFHead
  • YOLOXHead
  • SingleStageDetector
  • ATSS
  • AutoAssign
  • DetectionTransformer
  • SingleStageInstanceSegmentor
  • BoxInst
  • TwoStageDetector
  • CascadeRCNN
  • CenterNet
  • CondInst
  • DETR
  • ConditionalDETR
  • CornerNet
  • CrowdDet
  • Detectron2Wrapper
  • DABDETR
  • DDOD
  • DeformableDETR
  • DINO
  • FastRCNN
  • FasterRCNN
  • FCOS
+
+ + + + + + + + + + + + + + + + + + +
model (part 9)model (part 10)model (part 11)model (part 12)
  • FOVEA
  • FSAF
  • GFL
  • GridRCNN
  • HybridTaskCascade
  • KnowledgeDistillationSingleStageDetector
  • LAD
  • MaskFormer
  • Mask2Former
  • MaskRCNN
  • MaskScoringRCNN
  • NASFCOS
  • PAA
  • TwoStagePanopticSegmentor
  • PanopticFPN
  • PointRend
  • SparseRCNN
  • QueryInst
  • RepPointsDetector
  • RetinaNet
  • RPN
  • RTMDet
  • SCNet
  • SemiBaseDetector
  • SoftTeacher
  • SOLO
  • SOLOv2
  • TOOD
  • TridentFasterRCNN
  • VFNet
  • YOLACT
  • YOLOV3
  • YOLOF
  • YOLOX
  • BBoxHead
  • ConvFCBBoxHead
  • Shared2FCBBoxHead
  • Shared4Conv1FCBBoxHead
  • DIIHead
  • DoubleConvFCBBoxHead
  • MultiInstanceBBoxHead
  • SABLHead
  • SCNetBBoxHead
  • CascadeRoIHead
  • StandardRoIHead
  • DoubleHeadRoIHead
  • DynamicRoIHead
  • GridRoIHead
  • HybridTaskCascadeRoIHead
  • FCNMaskHead
  • CoarseMaskHead
  • DynamicMaskHead
  • FeatureRelayHead
  • FusedSemanticHead
  • GlobalContextHead
  • GridHead
  • HTCMaskHead
  • MaskPointHead
  • MaskIoUHead
  • SCNetMaskHead
  • SCNetSemanticHead
  • MaskScoringRoIHead
  • MultiInstanceRoIHead
  • PISARoIHead
  • PointRendRoIHead
  • GenericRoIExtractor
  • SingleRoIExtractor
  • SCNetRoIHead
  • ResLayer
  • SparseRoIHead
  • TridentRoIHead
  • BaseSemanticHead
  • PanopticFPNHead
  • BasePanopticFusionHead
  • HeuristicFusionHead
  • MaskFormerFusionHead
+
+
MMdetection Tools
+
+ + + + + + + + + + + + + + + + + + +
tools/dataset_converterstools/deploymenttoolstools/misc
  • pascal_voc.py
  • images2coco.py
  • cityscapes.py
  • mmdet2torchserve.py
  • test_torchserver.py
  • mmdet_handler.py
  • dist_test.sh
  • slurm_test.sh
  • test.py
  • dist_train.sh
  • train.py
  • slurm_train.sh
  • download_dataset.py
  • get_image_metas.py
  • gen_coco_panoptic_test_info.py
  • split_coco.py
  • get_crowdhuman_id_hw.py
  • print_config.py
+
+ + + + + + + + + + + + + + + + + + +
tools/model_converterstools/analysis_tools.dev_scripts (part 1).dev_scripts (part 2)
  • upgrade_model_version.py
  • upgrade_ssd_version.py
  • detectron2_to_mmdet.py
  • selfsup2mmdet.py
  • detectron2pytorch.py
  • regnet2mmdet.py
  • publish_model.py
  • benchmark.py
  • eval_metric.py
  • robustness_eval.py
  • confusion_matrix.py
  • optimize_anchors.py
  • browse_dataset.py
  • test_robustness.py
  • coco_error_analysis.py
  • coco_occluded_separated_recall.py
  • analyze_results.py
  • analyze_logs.py
  • get_flops.py
  • convert_test_benchmark_script.py
  • gather_test_benchmark_metric.py
  • benchmark_valid_flops.py
  • benchmark_train.py
  • test_benchmark.sh
  • download_checkpoints.py
  • benchmark_test_image.py
  • covignore.cfg
  • benchmark_full_models.txt
  • test_init_backbone.py
  • batch_train_list.txt
  • diff_coverage_test.sh
  • batch_test_list.py
  • linter.sh
  • gather_train_benchmark_metric.py
  • train_benchmark.sh
  • benchmark_inference_fps.py
  • benchmark_options.py
  • check_links.py
  • benchmark_test.py
  • benchmark_train_models.txt
  • convert_train_benchmark_script.py
  • gather_models.py
  • benchmark_filter.py
+
+ +## MMclassification (1.0.0rc5) + +
MMclassification Module Components
+
+ + + + + + + + + + + + + + + + + + + + +
visualizerdata sampleroptimizerbatch augmentmetric
  • ClsVisualizer
  • RepeatAugSampler
  • Adan
  • Lamb
  • Mixup
  • CutMix
  • ResizeMix
  • Accuracy
  • SingleLabelMetric
  • MultiLabelMetric
  • AveragePrecision
  • MultiTasksMetric
  • VOCMultiLabelMetric
  • VOCAveragePrecision
+
+ + + + + + + + + + + + + + + + + + +
hookdatasettransform (part 1)transform (part 2)
  • ClassNumCheckHook
  • EMAHook
  • SetAdaptiveMarginsHook
  • PreciseBNHook
  • PrepareProtoBeforeValLoopHook
  • SwitchRecipeHook
  • VisualizationHook
  • BaseDataset
  • CIFAR10
  • CIFAR100
  • CUB
  • CustomDataset
  • KFoldDataset
  • ImageNet
  • ImageNet21k
  • MNIST
  • FashionMNIST
  • MultiLabelDataset
  • MultiTaskDataset
  • VOC
  • AutoAugment
  • RandAugment
  • Shear
  • Translate
  • Rotate
  • AutoContrast
  • Invert
  • Equalize
  • Solarize
  • SolarizeAdd
  • Posterize
  • Contrast
  • ColorTransform
  • Brightness
  • Sharpness
  • Cutout
  • PackClsInputs
  • PackMultiTaskInputs
  • Transpose
  • ToPIL
  • ToNumpy
  • Collect
  • RandomCrop
  • RandomResizedCrop
  • EfficientNetRandomCrop
  • RandomErasing
  • EfficientNetCenterCrop
  • ResizeEdge
  • ColorJitter
  • Lighting
  • Albumentations
  • Albu
+
+ + + + + + + + + + + + + + + + + + +
model (part 1)model (part 2)model (part 3)model (part 4)
  • AlexNet
  • ShiftWindowMSA
  • ClsDataPreprocessor
  • VisionTransformer
  • BEiT
  • Conformer
  • ConvMixer
  • ResNet
  • ResNetV1c
  • ResNetV1d
  • ResNeXt
  • CSPDarkNet
  • CSPResNet
  • CSPResNeXt
  • DaViT
  • DistilledVisionTransformer
  • DeiT3
  • DenseNet
  • PoolFormer
  • EfficientFormer
  • EfficientNet
  • EfficientNetV2
  • HorNet
  • HRNet
  • InceptionV3
  • LeNet5
  • MixMIMTransformer
  • MlpMixer
  • MobileNetV2
  • MobileNetV3
  • MobileOne
  • MViT
  • RegNet
  • RepLKNet
  • RepMLPNet
  • RepVGG
  • Res2Net
  • ResNeSt
  • ResNet_CIFAR
  • RevVisionTransformer
  • SEResNet
  • SEResNeXt
  • ShuffleNetV1
  • ShuffleNetV2
  • SwinTransformer
  • SwinTransformerV2
  • T2T_ViT
  • TIMMBackbone
  • TNT
  • PCPVT
  • SVT
  • VAN
  • VGG
  • HuggingFaceClassifier
  • ImageClassifier
  • TimmClassifier
  • ClsHead
  • ConformerHead
  • VisionTransformerClsHead
  • DeiTClsHead
  • EfficientFormerClsHead
  • LinearClsHead
  • AsymmetricLoss
  • CrossEntropyLoss
  • FocalLoss
  • LabelSmoothLoss
  • SeesawLoss
  • ArcFaceClsHead
  • MultiLabelClsHead
  • CSRAClsHead
  • MultiLabelLinearClsHead
  • MultiTaskHead
  • StackedLinearClsHead
  • GlobalAveragePooling
  • GeneralizedMeanPooling
  • HRFuseScales
  • LinearReduction
  • ImageToImageRetriever
  • AverageClsScoreTTA
+
+
MMclassification Tools
+
+ + + + + + + + + + + + + + + + + + + + +
tools/misctools/visualizationstools/torchserve.dev_scriptstools/analysis_tools
  • verify_dataset.py
  • print_config.py
  • browse_dataset.py
  • vis_scheduler.py
  • vis_cam.py
  • mmcls_handler.py
  • mmcls2torchserve.py
  • test_torchserver.py
  • compare_init.py
  • ckpt_tree.py
  • generate_readme.py
  • eval_metric.py
  • analyze_results.py
  • analyze_logs.py
  • get_flops.py
+
+ + + + + + + + + + + + + + + + + + +
.dev_scripts/benchmark_regressiontoolstools/model_converters (part 1)tools/model_converters (part 2)
  • bench_train.yml
  • 4-benchmark_speed.py
  • 3-benchmark_train.py
  • 1-benchmark_valid.py
  • 2-benchmark_test.py
  • dist_test.sh
  • slurm_test.sh
  • test.py
  • dist_train.sh
  • train.py
  • slurm_train.sh
  • kfold-cross-valid.py
  • efficientnet_to_mmcls.py
  • repvgg_to_mmcls.py
  • clip_to_mmcls.py
  • reparameterize_model.py
  • shufflenetv2_to_mmcls.py
  • van2mmcls.py
  • hornet2mmcls.py
  • mixmimx_to_mmcls.py
  • edgenext_to_mmcls.py
  • torchvision_to_mmcls.py
  • twins2mmcls.py
  • revvit_to_mmcls.py
  • convnext_to_mmcls.py
  • replknet_to_mmcls.py
  • efficientnetv2_to_mmcls.py
  • mobilenetv2_to_mmcls.py
  • mlpmixer_to_mmcls.py
  • davit_to_mmcls.py
  • vgg_to_mmcls.py
  • deit3_to_mmcls.py
  • eva_to_mmcls.py
  • publish_model.py
  • tinyvit_to_mmcls.py
+
+ +## MMsegmentation (1.0.0rc5) + +
MMsegmentation Module Components
+
+ + + + + + + + + + + + + + + + + + + + +
task utilvisualizerhookoptimizer wrapper constructormetric
  • OHEMPixelSampler
  • SegLocalVisualizer
  • SegVisualizationHook
  • LearningRateDecayOptimizerConstructor
  • LayerDecayOptimizerConstructor
  • CitysMetric
  • IoUMetric
+
+ + + + + + + + + + + + + + + + + + +
dataset (part 1)dataset (part 2)transform (part 1)transform (part 2)
  • BaseSegDataset
  • ADE20KDataset
  • ChaseDB1Dataset
  • CityscapesDataset
  • COCOStuffDataset
  • DarkZurichDataset
  • MultiImageMixDataset
  • DecathlonDataset
  • DRIVEDataset
  • HRFDataset
  • iSAIDDataset
  • ISPRSDataset
  • LIPDataset
  • LoveDADataset
  • NightDrivingDataset
  • PascalContextDataset
  • PascalContextDataset59
  • PotsdamDataset
  • STAREDataset
  • SynapseDataset
  • PascalVOCDataset
  • PackSegInputs
  • LoadAnnotations
  • LoadImageFromNDArray
  • LoadBiomedicalImageFromFile
  • LoadBiomedicalAnnotation
  • LoadBiomedicalData
  • ResizeToMultiple
  • Rerange
  • CLAHE
  • RandomCrop
  • RandomRotate
  • RGB2Gray
  • AdjustGamma
  • SegRescale
  • PhotoMetricDistortion
  • RandomCutOut
  • RandomRotFlip
  • RandomMosaic
  • GenerateEdge
  • ResizeShortestEdge
  • BioMedical3DRandomCrop
  • BioMedicalGaussianNoise
  • BioMedicalGaussianBlur
  • BioMedicalRandomGamma
  • BioMedical3DPad
  • BioMedical3DRandomFlip
+
+ + + + + + + + + + + + + + + + + + +
model (part 1)model (part 2)model (part 3)model (part 4)
  • VisionTransformer
  • BEiT
  • BiSeNetV1
  • BiSeNetV2
  • CGNet
  • ERFNet
  • CrossEntropyLoss
  • DiceLoss
  • FocalLoss
  • LovaszLoss
  • TverskyLoss
  • ANNHead
  • APCHead
  • ASPPHead
  • FCNHead
  • CCHead
  • DAHead
  • DMHead
  • DNLHead
  • DPTHead
  • EMAHead
  • EncHead
  • FPNHead
  • GCHead
  • ISAHead
  • KernelUpdator
  • KernelUpdateHead
  • IterativeDecodeHead
  • LRASPPHead
  • Mask2FormerHead
  • MaskFormerHead
  • NLHead
  • OCRHead
  • PointHead
  • PSAHead
  • PSPHead
  • SegformerHead
  • SegmenterMaskTransformerHead
  • DepthwiseSeparableASPPHead
  • DepthwiseSeparableFCNHead
  • SETRMLAHead
  • SETRUPHead
  • STDCHead
  • UPerHead
  • FastSCNN
  • ResNet
  • ResNetV1c
  • ResNetV1d
  • HRNet
  • ICNet
  • MAE
  • MixVisionTransformer
  • MobileNetV2
  • MobileNetV3
  • ResNeSt
  • ResNeXt
  • STDCNet
  • STDCContextPathNet
  • SwinTransformer
  • TIMMBackbone
  • PCPVT
  • SVT
  • DeconvModule
  • InterpConv
  • UNet
  • SegDataPreProcessor
  • Feature2Pyramid
  • FPN
  • ICNeck
  • JPU
  • MLANeck
  • MultiLevelNeck
  • EncoderDecoder
  • CascadeEncoderDecoder
  • SegTTAModel
+
+
MMsegmentation Tools
+
+ + + + + + + + + + + + + + + + + + +
tools/deploymenttools/misctools/torchservetools/analysis_tools
  • pytorch2torchscript.py
  • browse_dataset.py
  • publish_model.py
  • print_config.py
  • mmseg_handler.py
  • mmseg2torchserve.py
  • test_torchserve.py
  • benchmark.py
  • confusion_matrix.py
  • analyze_logs.py
  • get_flops.py
+
+ + + + + + + + + + + + + + + + +
toolstools/model_converterstools/dataset_converters
  • dist_test.sh
  • slurm_test.sh
  • test.py
  • dist_train.sh
  • train.py
  • slurm_train.sh
  • swin2mmseg.py
  • vitjax2mmseg.py
  • twins2mmseg.py
  • stdc2mmseg.py
  • vit2mmseg.py
  • mit2mmseg.py
  • beit2mmseg.py
  • voc_aug.py
  • hrf.py
  • drive.py
  • pascal_context.py
  • vaihingen.py
  • stare.py
  • synapse.py
  • isaid.py
  • cityscapes.py
  • loveda.py
  • potsdam.py
  • chase_db1.py
  • coco_stuff164k.py
  • coco_stuff10k.py
+
+ +## MMengine (0.6.0) + +
MMengine Module Components
+
+ + + + + + + + + + + + + + + + + + + + +
log_processorvisualizermetricevaluatorrunner
  • LogProcessor
  • Visualizer
  • DumpResults
  • Evaluator
  • Runner
+
+ + + + + + + + + + + + + + + + + + + + +
optimizer wrapper constructorCollate Functionsdata samplervis_backenddataset
  • DefaultOptimWrapperConstructor
  • pseudo_collate
  • default_collate
  • DefaultSampler
  • InfiniteSampler
  • LocalVisBackend
  • WandbVisBackend
  • TensorboardVisBackend
  • ConcatDataset
  • RepeatDataset
  • ClassBalancedDataset
+
+ + + + + + + + + + + + + + + + + + + + +
optim_wrapperloopmodel_wrappermodelweight initializer
  • OptimWrapper
  • AmpOptimWrapper
  • ApexOptimWrapper
  • EpochBasedTrainLoop
  • IterBasedTrainLoop
  • ValLoop
  • TestLoop
  • DistributedDataParallel
  • DataParallel
  • MMDistributedDataParallel
  • MMSeparateDistributedDataParallel
  • StochasticWeightAverage
  • ExponentialMovingAverage
  • MomentumAnnealingEMA
  • BaseDataPreprocessor
  • ImgDataPreprocessor
  • BaseTTAModel
  • ToyModel
  • Constant
  • Xavier
  • Normal
  • TruncNormal
  • Uniform
  • Kaiming
  • Caffe2Xavier
  • Pretrained
+
+ + + + + + + + + + + + + + + + + + +
hookoptimizerparameter scheduler (part 1)parameter scheduler (part 2)
  • CheckpointHook
  • EMAHook
  • EmptyCacheHook
  • IterTimerHook
  • LoggerHook
  • NaiveVisualizationHook
  • ParamSchedulerHook
  • ProfilerHook
  • NPUProfilerHook
  • RuntimeInfoHook
  • DistSamplerSeedHook
  • SyncBuffersHook
  • PrepareTTAHook
  • ASGD
  • Adadelta
  • Adagrad
  • Adam
  • AdamW
  • Adamax
  • LBFGS
  • Optimizer
  • RMSprop
  • Rprop
  • SGD
  • SparseAdam
  • ZeroRedundancyOptimizer
  • StepParamScheduler
  • MultiStepParamScheduler
  • ConstantParamScheduler
  • ExponentialParamScheduler
  • CosineAnnealingParamScheduler
  • LinearParamScheduler
  • PolyParamScheduler
  • OneCycleParamScheduler
  • CosineRestartParamScheduler
  • ReduceOnPlateauParamScheduler
  • ConstantLR
  • CosineAnnealingLR
  • ExponentialLR
  • LinearLR
  • MultiStepLR
  • StepLR
  • PolyLR
  • OneCycleLR
  • CosineRestartLR
  • ReduceOnPlateauLR
  • ConstantMomentum
  • CosineAnnealingMomentum
  • ExponentialMomentum
  • LinearMomentum
  • MultiStepMomentum
  • StepMomentum
  • PolyMomentum
  • CosineRestartMomentum
  • ReduceOnPlateauMomentum
+
+ +## MMCV (2.0.0rc4) + +
MMCV Module Components
+
+ + + + + + + + + + + + + + + + + + +
transformmodel (part 1)model (part 2)model (part 3)
  • LoadImageFromFile
  • LoadAnnotations
  • Compose
  • KeyMapper
  • TransformBroadcaster
  • RandomChoice
  • RandomApply
  • Normalize
  • Resize
  • Pad
  • CenterCrop
  • RandomGrayscale
  • MultiScaleFlipAug
  • TestTimeAug
  • RandomChoiceResize
  • RandomFlip
  • RandomResize
  • ToTensor
  • ImageToTensor
  • ReLU
  • LeakyReLU
  • PReLU
  • RReLU
  • ReLU6
  • ELU
  • Sigmoid
  • Tanh
  • SiLU
  • Clamp
  • Clip
  • GELU
  • ContextBlock
  • Conv1d
  • Conv2d
  • Conv3d
  • Conv
  • Conv2dAdaptivePadding
  • BN
  • BN1d
  • BN2d
  • BN3d
  • SyncBN
  • GN
  • LN
  • IN
  • IN1d
  • IN2d
  • IN3d
  • zero
  • reflect
  • replicate
  • ConvModule
  • ConvWS
  • ConvAWS
  • DropPath
  • Dropout
  • GeneralizedAttention
  • HSigmoid
  • HSwish
  • NonLocal2d
  • Swish
  • nearest
  • bilinear
  • pixel_shuffle
  • deconv
  • ConvTranspose2d
  • deconv3d
  • ConvTranspose3d
  • MultiheadAttention
  • FFN
  • BaseTransformerLayer
  • TransformerLayerSequence
+
+
MMCV Tools
+
+ + + + + + + + + + + + +
.dev_scripts
  • check_installation.py
+
diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/resume_training.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/resume_training.md new file mode 100644 index 0000000000000000000000000000000000000000..36431e32dc89ea6d38333e547d11173d3c6c1996 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/resume_training.md @@ -0,0 +1,9 @@ +# 恢复训练 + +恢复训练是指从之前某次训练保存下来的状态开始继续训练，这里的状态包括模型的权重、优化器和优化器参数调整策略的状态。 + +用户可以在训练命令最后加上 `--resume` 恢复训练，程序会自动从 `work_dirs` 中加载最新的权重文件恢复训练。如果 `work_dir` 中有最新的 checkpoint（例如该训练在上一次训练时被中断），则会从该 checkpoint 恢复训练，否则（例如上一次训练还没来得及保存 checkpoint 或者启动了新的训练任务）会重新开始训练。下面是一个恢复训练的示例: + +```shell +python tools/train.py configs/yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py --resume +``` diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/set_random_seed.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/set_random_seed.md new file mode 100644 index 0000000000000000000000000000000000000000..6f747c54e890fae5816fbd5632cde8ac61f38f29 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/set_random_seed.md @@ -0,0 +1,20 @@ +# 设置随机种子 + +如果想要在训练时指定随机种子，可以使用以下命令： + +```shell +python ./tools/train.py \ + ${CONFIG} \ # 配置文件路径 + --cfg-options randomness.seed=2023 \ # 设置随机种子为 2023 + [randomness.diff_rank_seed=True] \ # 根据 rank 来设置不同的种子。 + [randomness.deterministic=True] # 把 cuDNN 后端确定性选项设置为 True +# [] 代表可选参数，实际输入命令行时，不用输入 [] +``` + +`randomness` 有三个参数可设置，具体含义如下： + +- `randomness.seed=2023` ，设置随机种子为 2023。 + +- `randomness.diff_rank_seed=True`，根据 rank 来设置不同的种子，`diff_rank_seed` 默认为 False。 + +- `randomness.deterministic=True`，把 cuDNN 后端确定性选项设置为 True，即把`torch.backends.cudnn.deterministic` 设为 True，把 `torch.backends.cudnn.benchmark` 设为False。`deterministic` 默认为 False。更多细节见 https://pytorch.org/docs/stable/notes/randomness.html。 diff --git a/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/set_syncbn.md b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/set_syncbn.md new file mode 100644 index 0000000000000000000000000000000000000000..a654a2b46f388371d031767de01fba7a618ceb70 --- /dev/null +++ b/video_gen_14d/third_party/VBench/VBench-2.0/vbench2/third_party/ViTDetector/third_party/YOLO-World/mmyolo/docs/zh_cn/common_usage/set_syncbn.md @@ -0,0 +1 @@ +# 开启和关闭 SyncBatchNorm