File size: 7,533 Bytes
fca4fc0 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 |
from PIL import Image
from io import BytesIO
import base64
import numpy as np
import torch
import decord
from transformers import StoppingCriteria
from vtimellm.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, IMAGE_SEGMENT_TOKEN_INDEX, DEFAULT_IMAGE_SEGMENT_TOKEN
def load_image_from_base64(image):
return Image.open(BytesIO(base64.b64decode(image)))
def process_images(images, image_processor, model_cfg):
return image_processor(images, return_tensors='pt')['pixel_values']
def tokenizer_image_token_bf(prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None):
def insert_separator(X, sep):
return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
prompt_chunks_t = prompt.split(DEFAULT_IMAGE_TOKEN)
if (len(prompt_chunks_t) > 1 and DEFAULT_IMAGE_SEGMENT_TOKEN in prompt_chunks_t[1]):
# incase <video segment> is present
prompt_chunks_seg_t = prompt_chunks_t[1].split(DEFAULT_IMAGE_SEGMENT_TOKEN)
prompt_t = [prompt_chunks_t[0]] + prompt_chunks_seg_t
prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt_t]
input_ids = []
offset = 0
# if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
# offset = 1
# input_ids.append(prompt_chunks[0][0])
input_ids = input_ids + prompt_chunks[0] + ([image_token_index] * (offset + 1))
offset = 1
# image segment token
for x in insert_separator(prompt_chunks[1:], [IMAGE_SEGMENT_TOKEN_INDEX] * (offset + 1)):
input_ids.extend(x[offset:])
if return_tensors is not None:
if return_tensors == 'pt':
return torch.tensor(input_ids, dtype=torch.long)
raise ValueError(f'Unsupported tensor type: {return_tensors}')
return input_ids
elif (len(prompt_chunks_t) == 1 and DEFAULT_IMAGE_SEGMENT_TOKEN in prompt_chunks_t[0]):
# Assumed no image token in such prompt
prompt_chunks_seg_t = prompt_chunks_t[0].split(DEFAULT_IMAGE_SEGMENT_TOKEN)
prompt_t = prompt_chunks_seg_t
prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt_t]
input_ids = []
offset = 0
# image segment token]
offset = 1
input_ids.append(prompt_chunks[0][0])
for x in insert_separator(prompt_chunks, [IMAGE_SEGMENT_TOKEN_INDEX] * (offset + 1)): input_ids.extend(x[offset:])
if return_tensors is not None:
if return_tensors == 'pt':
return torch.tensor(input_ids, dtype=torch.long)
raise ValueError(f'Unsupported tensor type: {return_tensors}')
return input_ids
else:
prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split(DEFAULT_IMAGE_TOKEN)]
input_ids = []
offset = 0
if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
offset = 1
input_ids.append(prompt_chunks[0][0])
elif tokenizer.name == "GLMTokenizer":
offset = 2
input_ids = prompt_chunks[0][:2]
for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):
input_ids.extend(x[offset:])
if return_tensors is not None:
if return_tensors == 'pt':
return torch.tensor(input_ids, dtype=torch.long)
raise ValueError(f'Unsupported tensor type: {return_tensors}')
return input_ids
def tokenizer_image_token(prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None):
prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split(DEFAULT_IMAGE_TOKEN)]
def insert_separator(X, sep):
return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
input_ids = []
offset = 0
if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
offset = 1
input_ids.append(prompt_chunks[0][0])
elif tokenizer.name == "GLMTokenizer":
offset = 2
input_ids = prompt_chunks[0][:2]
for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):
input_ids.extend(x[offset:])
if return_tensors is not None:
if return_tensors == 'pt':
return torch.tensor(input_ids, dtype=torch.long)
raise ValueError(f'Unsupported tensor type: {return_tensors}')
return input_ids
def get_model_name_from_path(model_path):
model_path = model_path.strip("/")
model_paths = model_path.split("/")
if model_paths[-1].startswith('checkpoint-'):
return model_paths[-2] + "_" + model_paths[-1]
else:
return model_paths[-1]
class KeywordsStoppingCriteria(StoppingCriteria):
def __init__(self, keywords, tokenizer, input_ids):
self.keywords = keywords
self.keyword_ids = []
for keyword in keywords:
cur_keyword_ids = tokenizer(keyword).input_ids
if len(cur_keyword_ids) > 1 and cur_keyword_ids[0] == tokenizer.bos_token_id:
cur_keyword_ids = cur_keyword_ids[1:]
self.keyword_ids.append(torch.tensor(cur_keyword_ids))
self.tokenizer = tokenizer
self.start_len = input_ids.shape[1]
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
assert output_ids.shape[0] == 1, "Only support batch size 1 (yet)" # TODO
offset = min(output_ids.shape[1] - self.start_len, 3)
self.keyword_ids = [keyword_id.to(output_ids.device) for keyword_id in self.keyword_ids]
for keyword_id in self.keyword_ids:
if output_ids[0, -keyword_id.shape[0]:].equal(keyword_id):
return True
outputs = self.tokenizer.batch_decode(output_ids[:, -offset:], skip_special_tokens=True)[0]
for keyword in self.keywords:
if keyword in outputs:
return True
return False
def print_trainable_parameters(model):
trainable_params = 0
all_param = 0
for _, param in model.named_parameters():
all_param += param.numel()
# print(_, param.requires_grad, param.numel())
if param.requires_grad:
trainable_params += param.numel()
print(
f"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param:.2f}"
)
class VideoExtractor():
"""Dataset for supervised fine-tuning."""
def __init__(self, N=100):
self.N = N
def extract(self, data):
video_path = data['video']
id = data['id']
try:
video_reader = decord.VideoReader(video_path)
total_frames = len(video_reader)
start = 0
end = total_frames - 1
split = data.get('split', None)
if split is not None:
fps = video_reader.get_avg_fps()
start = max(int(fps * split[0]), 0)
end = min(int(fps * split[1]), total_frames - 1)
sampled_indices = np.linspace(start, end, self.N, dtype=np.int32)
sampled_frames = video_reader.get_batch(sampled_indices).asnumpy()
except Exception as e:
print(e)
return None, torch.zeros(1)
images = torch.from_numpy(sampled_frames.transpose((0, 3, 1, 2)))
return id, images |