update
This commit is contained in:
echo840
@@ -1,21 +0,0 @@
|
||||
from transformers import Blip2Processor, Blip2ForConditionalGeneration
|
||||
import torch
|
||||
from PIL import Image
|
||||
from ..process import pad_image
|
||||
#There are some issues with the Hugging Face version of the BLIP2-opt model.
|
||||
class BLIP2:
|
||||
def __init__(self, model_path, device = "cuda") -> None:
|
||||
self.processor = Blip2Processor.from_pretrained(model_path)
|
||||
self.model = Blip2ForConditionalGeneration.from_pretrained(
|
||||
model_path, torch_dtype=torch.float16).to(device)
|
||||
self.model.eval()
|
||||
self.device = device
|
||||
def generate(self, image, question, pad=True):
|
||||
prompt =f'Question: {question} Answer:'
|
||||
image = Image.open(image)
|
||||
if pad:
|
||||
image = pad_image(image, (224,224))
|
||||
inputs = self.processor(images=image, text=prompt, return_tensors="pt").to(self.device, torch.float16)
|
||||
generated_ids = self.model.generate(**inputs)
|
||||
generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
|
||||
return generated_text
|
||||
Binary file not shown.
41
models/LLaVA/.github/ISSUE_TEMPLATE/1-usage.yaml
vendored
41
models/LLaVA/.github/ISSUE_TEMPLATE/1-usage.yaml
vendored
@@ -1,41 +0,0 @@
|
||||
name: Usage issues
|
||||
description: Report issues in usage.
|
||||
title: "[Usage] "
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thanks for taking the time to fill out this form. Please give as detailed description as possible for us to better assist with the issue :)
|
||||
- type: dropdown
|
||||
id: clone-date
|
||||
attributes:
|
||||
label: When did you clone our code?
|
||||
options:
|
||||
- I cloned the code base after 5/1/23
|
||||
- I cloned the code base before 5/1/23, but have pulled the latest code base
|
||||
- I cloned the code base before 5/1/23, and have not upgraded yet
|
||||
validations:
|
||||
required: true
|
||||
- type: textarea
|
||||
id: what-happened
|
||||
attributes:
|
||||
label: Describe the issue
|
||||
description: Please give as detailed description as possible for us to better assist with the issue. Please paste the **FULL** error log here, so that we can better understand the issue. Wrap the log with ``` for better readability in GitHub.
|
||||
placeholder: Issue
|
||||
value: |
|
||||
Issue:
|
||||
|
||||
Command:
|
||||
```
|
||||
PASTE THE COMMANDS HERE.
|
||||
```
|
||||
|
||||
Log:
|
||||
```
|
||||
PASTE THE LOGS HERE.
|
||||
```
|
||||
|
||||
Screenshots:
|
||||
You may attach screenshots if it better explains the issue.
|
||||
validations:
|
||||
required: true
|
||||
@@ -1,13 +0,0 @@
|
||||
name: Feature Request
|
||||
description: Request for a new feature
|
||||
title: "[Feature request] "
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thanks for your interest in our work. Please share your thoughts of the new features below.
|
||||
- type: textarea
|
||||
id: feature
|
||||
attributes:
|
||||
label: feature
|
||||
placeholder: Start your thoughts here...
|
||||
@@ -1,13 +0,0 @@
|
||||
name: Questions
|
||||
description: General questions about the work
|
||||
title: "[Question] "
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thanks for your interest in our work. For this type of question, it may be more suitable to go to [discussion](https://github.com/haotian-liu/LLaVA/discussions) sections. If you believe an issue would be better for your request, please continue your post below :)
|
||||
- type: textarea
|
||||
id: question
|
||||
attributes:
|
||||
label: Question
|
||||
placeholder: Start question here...
|
||||
@@ -1,13 +0,0 @@
|
||||
name: Discussions
|
||||
description: General discussions about the work
|
||||
title: "[Discussion] "
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
Thanks for your interest in our work. For this type of question, it may be more suitable to go to [discussion](https://github.com/haotian-liu/LLaVA/discussions) sections. If you believe an issue would be better for your request, please continue your post below :)
|
||||
- type: textarea
|
||||
id: discussion
|
||||
attributes:
|
||||
label: Discussion
|
||||
placeholder: Start discussion here...
|
||||
@@ -1 +0,0 @@
|
||||
from .model import LlavaLlamaForCausalLM
|
||||
@@ -1,4 +0,0 @@
|
||||
CONTROLLER_HEART_BEAT_EXPIRATION = 30
|
||||
WORKER_HEART_BEAT_INTERVAL = 15
|
||||
|
||||
LOGDIR = "."
|
||||
@@ -1,368 +0,0 @@
|
||||
import dataclasses
|
||||
from enum import auto, Enum
|
||||
from typing import List, Tuple
|
||||
|
||||
|
||||
class SeparatorStyle(Enum):
|
||||
"""Different separator style."""
|
||||
SINGLE = auto()
|
||||
TWO = auto()
|
||||
MPT = auto()
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class Conversation:
|
||||
"""A class that keeps all conversation history."""
|
||||
system: str
|
||||
roles: List[str]
|
||||
messages: List[List[str]]
|
||||
offset: int
|
||||
sep_style: SeparatorStyle = SeparatorStyle.SINGLE
|
||||
sep: str = "###"
|
||||
sep2: str = None
|
||||
version: str = "Unknown"
|
||||
|
||||
skip_next: bool = False
|
||||
|
||||
def get_prompt(self):
|
||||
if self.sep_style == SeparatorStyle.SINGLE:
|
||||
ret = self.system + self.sep
|
||||
for role, message in self.messages:
|
||||
if message:
|
||||
if type(message) is tuple:
|
||||
message, _, _ = message
|
||||
ret += role + ": " + message + self.sep
|
||||
else:
|
||||
ret += role + ":"
|
||||
return ret
|
||||
elif self.sep_style == SeparatorStyle.TWO:
|
||||
seps = [self.sep, self.sep2]
|
||||
ret = self.system + seps[0]
|
||||
for i, (role, message) in enumerate(self.messages):
|
||||
if message:
|
||||
if type(message) is tuple:
|
||||
message, _, _ = message
|
||||
ret += role + ": " + message + seps[i % 2]
|
||||
else:
|
||||
ret += role + ":"
|
||||
return ret
|
||||
if self.sep_style == SeparatorStyle.MPT:
|
||||
ret = self.system + self.sep
|
||||
for role, message in self.messages:
|
||||
if message:
|
||||
if type(message) is tuple:
|
||||
message, _, _ = message
|
||||
ret += role + message + self.sep
|
||||
else:
|
||||
ret += role
|
||||
return ret
|
||||
else:
|
||||
raise ValueError(f"Invalid style: {self.sep_style}")
|
||||
|
||||
def append_message(self, role, message):
|
||||
self.messages.append([role, message])
|
||||
|
||||
def get_images(self, return_pil=False):
|
||||
images = []
|
||||
for i, (role, msg) in enumerate(self.messages[self.offset:]):
|
||||
if i % 2 == 0:
|
||||
if type(msg) is tuple:
|
||||
import base64
|
||||
from io import BytesIO
|
||||
from PIL import Image
|
||||
msg, image, image_process_mode = msg
|
||||
if image_process_mode == "Pad":
|
||||
def expand2square(pil_img, background_color=(122, 116, 104)):
|
||||
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)
|
||||
elif image_process_mode == "Crop":
|
||||
pass
|
||||
elif image_process_mode == "Resize":
|
||||
image = image.resize((224, 224))
|
||||
else:
|
||||
raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
|
||||
max_hw, min_hw = max(image.size), min(image.size)
|
||||
aspect_ratio = max_hw / min_hw
|
||||
max_len, min_len = 800, 400
|
||||
shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
|
||||
longest_edge = int(shortest_edge * aspect_ratio)
|
||||
W, H = image.size
|
||||
if H > W:
|
||||
H, W = longest_edge, shortest_edge
|
||||
else:
|
||||
H, W = shortest_edge, longest_edge
|
||||
image = image.resize((W, H))
|
||||
if return_pil:
|
||||
images.append(image)
|
||||
else:
|
||||
buffered = BytesIO()
|
||||
image.save(buffered, format="JPEG")
|
||||
img_b64_str = base64.b64encode(buffered.getvalue()).decode()
|
||||
images.append(img_b64_str)
|
||||
return images
|
||||
|
||||
def to_gradio_chatbot(self):
|
||||
ret = []
|
||||
for i, (role, msg) in enumerate(self.messages[self.offset:]):
|
||||
if i % 2 == 0:
|
||||
if type(msg) is tuple:
|
||||
import base64
|
||||
from io import BytesIO
|
||||
msg, image, image_process_mode = msg
|
||||
max_hw, min_hw = max(image.size), min(image.size)
|
||||
aspect_ratio = max_hw / min_hw
|
||||
max_len, min_len = 800, 400
|
||||
shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
|
||||
longest_edge = int(shortest_edge * aspect_ratio)
|
||||
W, H = image.size
|
||||
if H > W:
|
||||
H, W = longest_edge, shortest_edge
|
||||
else:
|
||||
H, W = shortest_edge, longest_edge
|
||||
image = image.resize((W, H))
|
||||
# image = image.resize((224, 224))
|
||||
buffered = BytesIO()
|
||||
image.save(buffered, format="JPEG")
|
||||
img_b64_str = base64.b64encode(buffered.getvalue()).decode()
|
||||
img_str = f'<img src="data:image/png;base64,{img_b64_str}" alt="user upload image" />'
|
||||
msg = msg.replace('<image>', img_str)
|
||||
ret.append([msg, None])
|
||||
else:
|
||||
ret[-1][-1] = msg
|
||||
return ret
|
||||
|
||||
def copy(self):
|
||||
return Conversation(
|
||||
system=self.system,
|
||||
roles=self.roles,
|
||||
messages=[[x, y] for x, y in self.messages],
|
||||
offset=self.offset,
|
||||
sep_style=self.sep_style,
|
||||
sep=self.sep,
|
||||
sep2=self.sep2)
|
||||
|
||||
def dict(self):
|
||||
if len(self.get_images()) > 0:
|
||||
return {
|
||||
"system": self.system,
|
||||
"roles": self.roles,
|
||||
"messages": [[x, y[0] if type(y) is tuple else y] for x, y in self.messages],
|
||||
"offset": self.offset,
|
||||
"sep": self.sep,
|
||||
"sep2": self.sep2,
|
||||
}
|
||||
return {
|
||||
"system": self.system,
|
||||
"roles": self.roles,
|
||||
"messages": self.messages,
|
||||
"offset": self.offset,
|
||||
"sep": self.sep,
|
||||
"sep2": self.sep2,
|
||||
}
|
||||
|
||||
|
||||
conv_v1 = Conversation(
|
||||
system="A chat between a curious human and an artificial intelligence assistant. "
|
||||
"The assistant gives helpful, detailed, and polite answers to the human's questions.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Give three tips for staying healthy."),
|
||||
("Assistant",
|
||||
"Sure, here are three tips for staying healthy:\n"
|
||||
"1. Exercise regularly: Regular physical activity can help improve your overall health and wellbeing. "
|
||||
"It can also help reduce your risk of chronic conditions such as obesity, diabetes, heart disease, "
|
||||
"and certain cancers. Aim for at least 150 minutes of moderate-intensity aerobic exercise or "
|
||||
"75 minutes of vigorous-intensity aerobic exercise per week, along with muscle-strengthening "
|
||||
"activities at least two days per week.\n"
|
||||
"2. Eat a balanced diet: Eating a balanced diet that is rich in fruits, "
|
||||
"vegetables, whole grains, lean proteins, and healthy fats can help support "
|
||||
"your overall health. Try to limit your intake of processed and high-sugar foods, "
|
||||
"and aim to drink plenty of water throughout the day.\n"
|
||||
"3. Get enough sleep: Getting enough quality sleep is essential for your physical "
|
||||
"and mental health. Adults should aim for seven to nine hours of sleep per night. "
|
||||
"Establish a regular sleep schedule and try to create a relaxing bedtime routine to "
|
||||
"help improve the quality of your sleep.")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
conv_v1_2 = Conversation(
|
||||
system="A chat between a curious human and an artificial intelligence assistant. "
|
||||
"The assistant gives helpful, detailed, and polite answers to the human's questions.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "What are the key differences between renewable and non-renewable energy sources?"),
|
||||
("Assistant",
|
||||
"Renewable energy sources are those that can be replenished naturally in a relatively "
|
||||
"short amount of time, such as solar, wind, hydro, geothermal, and biomass. "
|
||||
"Non-renewable energy sources, on the other hand, are finite and will eventually be "
|
||||
"depleted, such as coal, oil, and natural gas. Here are some key differences between "
|
||||
"renewable and non-renewable energy sources:\n"
|
||||
"1. Availability: Renewable energy sources are virtually inexhaustible, while non-renewable "
|
||||
"energy sources are finite and will eventually run out.\n"
|
||||
"2. Environmental impact: Renewable energy sources have a much lower environmental impact "
|
||||
"than non-renewable sources, which can lead to air and water pollution, greenhouse gas emissions, "
|
||||
"and other negative effects.\n"
|
||||
"3. Cost: Renewable energy sources can be more expensive to initially set up, but they typically "
|
||||
"have lower operational costs than non-renewable sources.\n"
|
||||
"4. Reliability: Renewable energy sources are often more reliable and can be used in more remote "
|
||||
"locations than non-renewable sources.\n"
|
||||
"5. Flexibility: Renewable energy sources are often more flexible and can be adapted to different "
|
||||
"situations and needs, while non-renewable sources are more rigid and inflexible.\n"
|
||||
"6. Sustainability: Renewable energy sources are more sustainable over the long term, while "
|
||||
"non-renewable sources are not, and their depletion can lead to economic and social instability.\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
conv_vicuna_v1_1 = Conversation(
|
||||
system="A chat between a curious user and an artificial intelligence assistant. "
|
||||
"The assistant gives helpful, detailed, and polite answers to the user's questions.",
|
||||
roles=("USER", "ASSISTANT"),
|
||||
version="v1",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.TWO,
|
||||
sep=" ",
|
||||
sep2="</s>",
|
||||
)
|
||||
|
||||
conv_mpt = Conversation(
|
||||
system="""<|im_start|>system
|
||||
- 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.
|
||||
- You should follow the instructions carefully and explain your answers in detail.""",
|
||||
roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
|
||||
version="mpt",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.MPT,
|
||||
sep="<|im_end|>",
|
||||
)
|
||||
|
||||
conv_mpt_text = Conversation(
|
||||
system="""<|im_start|>system
|
||||
- You are a helpful assistant chatbot trained by MosaicML.
|
||||
- You answer questions.
|
||||
- You are excited to be able to help the user, but will refuse to do anything that could be considered harmful to the user.
|
||||
- You are more than just an information source, you are also able to write poetry, short stories, and make jokes.""",
|
||||
roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
|
||||
version="mpt",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.MPT,
|
||||
sep="<|im_end|>",
|
||||
)
|
||||
|
||||
conv_bair_v1 = Conversation(
|
||||
system="BEGINNING OF CONVERSATION:",
|
||||
roles=("USER", "GPT"),
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.TWO,
|
||||
sep=" ",
|
||||
sep2="</s>",
|
||||
)
|
||||
|
||||
simple_conv = Conversation(
|
||||
system="You are LLaVA, a large language model trained by UW Madison WAIV Lab, based on LLaMA architecture."
|
||||
"You are designed to assist human with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Hi!"),
|
||||
("Assistant", "Hi there! How can I help you today?\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
simple_conv_multimodal = Conversation(
|
||||
system="You are LLaVA, a large language and vision assistant trained by UW Madison WAIV Lab."
|
||||
"You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully and explain your answers in detail.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Hi!"),
|
||||
("Assistant", "Hi there! How can I help you today?\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
simple_conv_mpt_multimodal = Conversation(
|
||||
system="""<|im_start|>system
|
||||
- You are LLaVA, a large language and vision assistant trained by UW Madison WAIV Lab.
|
||||
- You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.
|
||||
- You should follow the instructions carefully and explain your answers in detail.""",
|
||||
roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
|
||||
version="mpt",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.MPT,
|
||||
sep="<|im_end|>",
|
||||
)
|
||||
|
||||
simple_conv_legacy = Conversation(
|
||||
system="You are LLaVA, a large language model trained by UW Madison WAIV Lab."
|
||||
"You are designed to assist human with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Hi!\n\n### Response:"),
|
||||
("Assistant", "Hi there! How can I help you today?\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
conv_llava_v1 = Conversation(
|
||||
system="You are LLaVA, a large language and vision assistant trained by UW Madison WAIV Lab."
|
||||
"You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully and explain your answers in detail.",
|
||||
roles=("USER", "ASSISTANT"),
|
||||
version="v1",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.TWO,
|
||||
sep=" ",
|
||||
sep2="</s>",
|
||||
)
|
||||
|
||||
default_conversation = conv_v1_2
|
||||
conv_templates = {
|
||||
"default": conv_v1_2,
|
||||
"simple": simple_conv,
|
||||
"simple_legacy": simple_conv_legacy,
|
||||
"multimodal": simple_conv_multimodal,
|
||||
"mpt_multimodal": simple_conv_mpt_multimodal,
|
||||
"llava_v1": conv_llava_v1,
|
||||
|
||||
# fastchat
|
||||
"v1": conv_v1_2,
|
||||
"bair_v1": conv_bair_v1,
|
||||
"vicuna_v1_1": conv_vicuna_v1_1,
|
||||
"mpt": conv_mpt,
|
||||
"mpt_text": conv_mpt_text,
|
||||
}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(default_conversation.get_prompt())
|
||||
@@ -1,58 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import pathlib
|
||||
|
||||
# Prompt from stanford alpaca's training script
|
||||
PROMPT_DICT = {
|
||||
"prompt_input": (
|
||||
"Below is an instruction that describes a task, paired with an input that provides further context. "
|
||||
"Write a response that appropriately completes the request.\n\n"
|
||||
"### Instruction:\n{instruction}\n\n### Input:\n{input}\n\n### Response:"
|
||||
),
|
||||
"prompt_no_input": (
|
||||
"Below is an instruction that describes a task. "
|
||||
"Write a response that appropriately completes the request.\n\n"
|
||||
"### Instruction:\n{instruction}\n\n### Response:"
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def main(args):
|
||||
data_path = pathlib.Path(args.data_path)
|
||||
with data_path.open() as f:
|
||||
data = json.load(f)
|
||||
|
||||
prompt_input, prompt_no_input = PROMPT_DICT["prompt_input"], PROMPT_DICT["prompt_no_input"]
|
||||
sources = [
|
||||
prompt_input.format_map(example) if example.get("input", "") != "" else prompt_no_input.format_map(example)
|
||||
for example in data
|
||||
]
|
||||
targets = [example['output'] for example in data]
|
||||
|
||||
new_data = []
|
||||
cnt = 1
|
||||
for s, t in zip(sources, targets):
|
||||
new_data.append({
|
||||
'id': str(cnt),
|
||||
'conversations': [
|
||||
{
|
||||
'from': 'human',
|
||||
'value': s,
|
||||
},
|
||||
{
|
||||
'from': 'gpt',
|
||||
'value': t,
|
||||
}
|
||||
]
|
||||
})
|
||||
cnt += 1
|
||||
|
||||
json.dump(new_data, open(args.output_path, 'w'), indent=2)
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--data_path', type=str, default='alpaca-data.json')
|
||||
parser.add_argument('--output_path', type=str, default='alpaca-data-conversation.json')
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
|
||||
@@ -1,195 +0,0 @@
|
||||
"""
|
||||
- Convert html to markdown with basic data cleaning.
|
||||
- Deduplication.
|
||||
|
||||
Usage:
|
||||
python3 -m fastchat.data.clean_sharegpt --in sharegpt_html.json --out sharegpt_clean.json
|
||||
"""
|
||||
import argparse
|
||||
from concurrent.futures import ProcessPoolExecutor
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from typing import Dict, Union
|
||||
|
||||
import bs4
|
||||
import markdownify # == 0.11.6
|
||||
from tqdm import tqdm
|
||||
|
||||
|
||||
div_pattern = re.compile("<div.*?>")
|
||||
span_pattern = re.compile("<span.*?>")
|
||||
code_lang_pattern = re.compile(
|
||||
"```\s*" + "(.*?)" + "(?:Copy code)+" + "(.+?)" + "\s*?```", re.DOTALL
|
||||
)
|
||||
code_lang_format = "```\g<1>\n\g<2>\n```"
|
||||
regenerate_pattern = re.compile("\d+ / \d+")
|
||||
copy_chars_pattern = re.compile("Copy\d+ chars / \d+ words")
|
||||
copy_code_pattern = re.compile("```(.*?)Copy code\s*```")
|
||||
|
||||
|
||||
def reformat_code(val: str) -> str:
|
||||
# Input code format is:
|
||||
# ```
|
||||
# $<language>Copy code$<exact_code_here>
|
||||
#
|
||||
# ```
|
||||
# This function convert it into the correct markdown format
|
||||
return re.sub(code_lang_pattern, code_lang_format, val)
|
||||
|
||||
|
||||
def html_to_markdown(val: str) -> str:
|
||||
# Remove all <div>. This is required to make intent work in code blocks.
|
||||
val = re.sub(div_pattern, "", val)
|
||||
# Remove all <span>. This is required to make underscores work in code blocks.
|
||||
val = re.sub(span_pattern, "", val)
|
||||
# Markdown to html
|
||||
val = markdownify.markdownify(val).strip()
|
||||
# Reformat code
|
||||
val = reformat_code(val)
|
||||
|
||||
# Remove noisy "[number] / [number]" at the beginning
|
||||
noise = re.search(regenerate_pattern, val)
|
||||
if noise and noise.start() == 0:
|
||||
val = val[noise.end() :]
|
||||
# Remove noisy "Copy[number] chars / [number] words"
|
||||
val = re.sub(copy_chars_pattern, "", val)
|
||||
# Remove empty code block ```\nCopy code\n```
|
||||
val = re.sub(copy_code_pattern, "", val)
|
||||
|
||||
# Strip
|
||||
val = val.replace("\n\n\n", "\n").strip()
|
||||
|
||||
return val
|
||||
|
||||
|
||||
def contain_blocked_words(val: str) -> bool:
|
||||
blocked_words = ["openai", "chatgpt"]
|
||||
for w in blocked_words:
|
||||
if w in val.lower():
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def clean_html_one_sample(sample):
|
||||
roles = ["human", "gpt"]
|
||||
|
||||
if len(sample["conversations"]) <= 1:
|
||||
return (sample, 1)
|
||||
|
||||
# Adjust the offset for cases like https://sharegpt.com/c/VyaZlh4
|
||||
if sample["conversations"][0]["from"] != "human":
|
||||
sample["conversations"] = sample["conversations"][1:]
|
||||
if len(sample["conversations"]) <= 1:
|
||||
return (sample, 1)
|
||||
|
||||
if sample["conversations"][-1]["from"] == "human":
|
||||
sample["conversations"] = sample["conversations"][:-1]
|
||||
if len(sample["conversations"]) <= 1:
|
||||
return (sample, 1)
|
||||
|
||||
for i, c in enumerate(sample["conversations"]):
|
||||
if c["from"] != roles[i % 2]:
|
||||
return (sample, 2)
|
||||
|
||||
if contain_blocked_words(c["value"]):
|
||||
return (sample, 3)
|
||||
|
||||
try:
|
||||
new_val = html_to_markdown(c["value"])
|
||||
except (bs4.builder.ParserRejectedMarkup, AssertionError):
|
||||
return (sample, 4)
|
||||
|
||||
c["value"] = new_val
|
||||
|
||||
return (sample, 0)
|
||||
|
||||
|
||||
def clean_html_all(content, begin, end):
|
||||
"""
|
||||
Clean the source html files.
|
||||
"""
|
||||
cnt_skip = 0
|
||||
cnt_blocked_words = 0
|
||||
cnt_wrong_format = 0
|
||||
cnt_parser_error = 0
|
||||
cnt_too_short = 0
|
||||
cnt_id_duplication = 0
|
||||
cnt_value_duplication = 0
|
||||
cnt_tag = 0
|
||||
|
||||
content = content[begin:end]
|
||||
processed = []
|
||||
with ProcessPoolExecutor() as executor:
|
||||
for result in tqdm(
|
||||
executor.map(clean_html_one_sample, content), total=len(content)
|
||||
):
|
||||
processed.append(result)
|
||||
|
||||
visited = {}
|
||||
new_content = []
|
||||
for sample, error_code in tqdm(processed):
|
||||
cid = sample["id"]
|
||||
skipped = True
|
||||
|
||||
if error_code != 0:
|
||||
if error_code == 1:
|
||||
print(f"id {cid} is too short")
|
||||
cnt_too_short += 1
|
||||
elif error_code == 2:
|
||||
print(f"id {cid} has a wrong format")
|
||||
cnt_wrong_format += 1
|
||||
elif error_code == 3:
|
||||
print(f"id {cid} contains blocked words")
|
||||
cnt_blocked_words += 1
|
||||
elif error_code == 4:
|
||||
print(f"id {cid} contains parser errors")
|
||||
cnt_parser_error += 1
|
||||
else:
|
||||
raise ValueError(f"Invalid error_code: {error_code}")
|
||||
elif cid in visited:
|
||||
print(f"id {cid} is an id duplication of {visited[cid]}")
|
||||
cnt_id_duplication += 1
|
||||
elif (
|
||||
sample["conversations"][1]["value"],
|
||||
len(sample["conversations"]),
|
||||
) in visited:
|
||||
key = (sample["conversations"][1]["value"], len(sample["conversations"]))
|
||||
print(f"id {cid} is a value duplication of {visited[key]}")
|
||||
cnt_value_duplication += 1
|
||||
else:
|
||||
key = (sample["conversations"][1]["value"], len(sample["conversations"]))
|
||||
visited[cid] = visited[key] = cid
|
||||
skipped = False
|
||||
|
||||
if not skipped:
|
||||
new_content.append(sample)
|
||||
else:
|
||||
cnt_skip += 1
|
||||
|
||||
print(
|
||||
f"total: {len(content)}, skip: {cnt_skip}, new: {len(new_content)}, "
|
||||
f"cnt_blocked_words: {cnt_blocked_words}, cnt_parser_error: {cnt_parser_error}, "
|
||||
f"cnt_wrong_format: {cnt_wrong_format}, "
|
||||
f"cnt_too_short: {cnt_too_short}, cnt_id_duplication: {cnt_id_duplication}, "
|
||||
f"cnt_value_duplication: {cnt_value_duplication}, "
|
||||
)
|
||||
|
||||
return new_content
|
||||
|
||||
|
||||
def main(args):
|
||||
content = json.load(open(args["in_file"], "r"))
|
||||
content = clean_html_all(content, args["begin"], args["end"])
|
||||
json.dump(content, open(args["out_file"], "w"), indent=2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, default="sharegpt_clean.json")
|
||||
parser.add_argument("--begin", type=int)
|
||||
parser.add_argument("--end", type=int)
|
||||
parser.add_argument("--debug", action="store_true")
|
||||
args = parser.parse_args()
|
||||
main(vars(args))
|
||||
@@ -1,23 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.data.inspect --in sharegpt_20230322_clean_lang_split.json
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
|
||||
import tqdm
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--begin", type=int)
|
||||
args = parser.parse_args()
|
||||
|
||||
content = json.load(open(args.in_file, "r"))
|
||||
for sample in tqdm.tqdm(content[args.begin:]):
|
||||
print(f"id: {sample['id']}")
|
||||
for conv in sample["conversations"]:
|
||||
print(conv["from"] + ": ")
|
||||
print(conv["value"])
|
||||
input()
|
||||
@@ -1,80 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.data.optional_clean --lang en --reduce-rep --in sharegpt_clean.json --out output.json
|
||||
python3 -m fastchat.data.optional_clean --skip-lang en --reduce-rep --in sharegpt_clean.json --out output.json
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import re
|
||||
|
||||
import polyglot
|
||||
from polyglot.detect import Detector
|
||||
import pycld2
|
||||
from tqdm import tqdm
|
||||
|
||||
|
||||
def skip(conv, args):
|
||||
# Remove certain languages
|
||||
if args.lang != "all" or args.skip_lang is not None:
|
||||
text = "\n".join([x["value"] for x in conv["conversations"]])
|
||||
try:
|
||||
lang_code = Detector(text).language.code
|
||||
except (pycld2.error, polyglot.detect.base.UnknownLanguage):
|
||||
lang_code = "unknown"
|
||||
|
||||
if args.lang != "all" and lang_code != args.lang:
|
||||
return True
|
||||
|
||||
if lang_code == args.skip_lang:
|
||||
return True
|
||||
|
||||
# Remove repetitive numbers
|
||||
if args.reduce_rep:
|
||||
for sentence in conv["conversations"]:
|
||||
val = sentence["value"]
|
||||
sub = re.search(r"(\d)\1{8}", val)
|
||||
if sub is not None:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, default="")
|
||||
parser.add_argument("--lang", type=str, default="all",
|
||||
choices=["all", "en"])
|
||||
parser.add_argument("--skip-lang", type=str)
|
||||
# NOTE: Be careful about reduce_rep which may remove some good data.
|
||||
# For example, addresses could have long consecutive 0's
|
||||
parser.add_argument("--reduce-rep", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
in_file = args.in_file
|
||||
out_file = args.out_file
|
||||
lang = args.lang
|
||||
skip_lang = args.skip_lang
|
||||
reduce_rep = args.reduce_rep
|
||||
assert (lang == "all" or skip_lang is None)
|
||||
|
||||
if out_file == "":
|
||||
out_file = "sharegpt_clean"
|
||||
if lang != "all":
|
||||
out_file += "_" + lang
|
||||
if skip_lang is not None:
|
||||
out_file += "_skip_" + skip_lang
|
||||
if reduce_rep:
|
||||
out_file += "_reduce_rep"
|
||||
out_file += ".json"
|
||||
|
||||
content = json.load(open(in_file, "r"))
|
||||
num_conv = len(content)
|
||||
|
||||
new_content = []
|
||||
for conv in tqdm(content):
|
||||
if not skip(conv, args):
|
||||
new_content.append(conv)
|
||||
|
||||
print(f"return {len(new_content)} out of {len(content)}, start dump ...")
|
||||
json.dump(new_content, open(out_file, "w"), indent=2)
|
||||
@@ -1,20 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 pretty_json.py --in in.json --out out.json
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, required=True)
|
||||
args = parser.parse_args()
|
||||
|
||||
with open(args.in_file, "r") as fin:
|
||||
data = json.load(fin)
|
||||
|
||||
with open(args.out_file, "w") as fout:
|
||||
json.dump(data, fout, indent=2)
|
||||
@@ -1,99 +0,0 @@
|
||||
"""
|
||||
Split long conversations based on certain max length.
|
||||
|
||||
Usage: python3 -m fastchat.data.split_long_conversation \
|
||||
--in sharegpt_clean.json \
|
||||
--out sharegpt_split.json \
|
||||
--model-name-or-path $<model-name>
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
from typing import Dict, Sequence, Optional
|
||||
|
||||
import transformers
|
||||
import tqdm
|
||||
|
||||
from llava import conversation as conversation_lib
|
||||
|
||||
DEFAULT_PAD_TOKEN = "[PAD]"
|
||||
BEGIN_SIGNAL = "### "
|
||||
END_SIGNAL = "\n"
|
||||
|
||||
|
||||
def split_sample(sample, start_idx, end_idx):
|
||||
# only ends in the bot because otherwise the last human part is useless.
|
||||
end_speaker = sample["conversations"][end_idx]["from"]
|
||||
end_idx = end_idx + 1 if end_speaker != "human" else end_idx
|
||||
return {
|
||||
"id": sample["id"] + "_" + str(start_idx),
|
||||
"conversations": sample["conversations"][start_idx:end_idx]
|
||||
}
|
||||
|
||||
|
||||
def split_contents(content, begin, end, tokenizer, max_length):
|
||||
"""
|
||||
Keep the maximum round of conversations within the max token length constraint
|
||||
"""
|
||||
content = content[begin:end]
|
||||
new_content = []
|
||||
|
||||
for sample in tqdm.tqdm(content):
|
||||
tokenized_lens = []
|
||||
|
||||
for c in sample["conversations"]:
|
||||
from_str = c["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 = (BEGIN_SIGNAL + from_str + ": " + c["value"] +
|
||||
END_SIGNAL)
|
||||
length = tokenizer(sentence, return_tensors="pt", padding="longest"
|
||||
).input_ids.ne(tokenizer.pad_token_id).sum().item()
|
||||
tokenized_lens.append(length)
|
||||
|
||||
num_tokens = 0
|
||||
start_idx = 0
|
||||
for idx, l in enumerate(tokenized_lens):
|
||||
# TODO: shall we also only starts from a specific speaker?
|
||||
if num_tokens + l > max_length:
|
||||
new_content.append(split_sample(sample, start_idx, idx))
|
||||
start_idx = idx
|
||||
num_tokens = l
|
||||
else:
|
||||
num_tokens += l
|
||||
if idx == len(tokenized_lens) - 1:
|
||||
new_content.append(split_sample(sample, start_idx, idx))
|
||||
|
||||
print(f"total: {len(content)}, new: {len(new_content)}")
|
||||
return new_content
|
||||
|
||||
|
||||
def main(args):
|
||||
content = json.load(open(args.in_file, "r"))
|
||||
tokenizer = transformers.AutoTokenizer.from_pretrained(
|
||||
args.model_name_or_path,
|
||||
model_max_length=args.max_length,
|
||||
padding_side="right",
|
||||
use_fast=False,
|
||||
)
|
||||
if tokenizer.pad_token is None:
|
||||
tokenizer.add_special_tokens(dict(pad_token=DEFAULT_PAD_TOKEN))
|
||||
content = split_contents(content, args.begin, args.end,
|
||||
tokenizer, args.max_length)
|
||||
json.dump(content, open(args.out_file, "w"), indent=2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, default="sharegpt_split.json")
|
||||
parser.add_argument("--begin", type=int)
|
||||
parser.add_argument("--end", type=int)
|
||||
parser.add_argument("--model-name-or-path", type=str, required=True)
|
||||
parser.add_argument("--max-length", type=int, default=2304)
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
@@ -1,111 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
|
||||
import openai
|
||||
import tqdm
|
||||
import ray
|
||||
import time
|
||||
|
||||
@ray.remote(num_cpus=4)
|
||||
def get_eval(content: str, max_tokens: int):
|
||||
while True:
|
||||
try:
|
||||
response = openai.ChatCompletion.create(
|
||||
model='gpt-4',
|
||||
messages=[{
|
||||
'role': 'system',
|
||||
'content': 'You are a helpful and precise assistant for checking the quality of the answer.'
|
||||
}, {
|
||||
'role': 'user',
|
||||
'content': content,
|
||||
}],
|
||||
temperature=0.2, # TODO: figure out which temperature is best for evaluation
|
||||
max_tokens=max_tokens,
|
||||
)
|
||||
break
|
||||
except openai.error.RateLimitError:
|
||||
pass
|
||||
except Exception as e:
|
||||
print(e)
|
||||
time.sleep(1)
|
||||
|
||||
print('success!')
|
||||
return response['choices'][0]['message']['content']
|
||||
|
||||
|
||||
def parse_score(review):
|
||||
try:
|
||||
score_pair = review.split('\n')[0]
|
||||
score_pair = score_pair.replace(',', ' ')
|
||||
sp = score_pair.split(' ')
|
||||
if len(sp) == 2:
|
||||
return [float(sp[0]), float(sp[1])]
|
||||
else:
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
except Exception as e:
|
||||
print(e)
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
|
||||
parser.add_argument('-q', '--question')
|
||||
# parser.add_argument('-a', '--answer')
|
||||
parser.add_argument('-a', '--answer-list', nargs='+', default=[])
|
||||
parser.add_argument('-r', '--rule')
|
||||
parser.add_argument('-o', '--output')
|
||||
parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
|
||||
args = parser.parse_args()
|
||||
|
||||
ray.init()
|
||||
|
||||
f_q = open(os.path.expanduser(args.question))
|
||||
f_ans1 = open(os.path.expanduser(args.answer_list[0]))
|
||||
f_ans2 = open(os.path.expanduser(args.answer_list[1]))
|
||||
rule_dict = json.load(open(os.path.expanduser(args.rule), 'r'))
|
||||
|
||||
review_file = open(f'{args.output}', 'w')
|
||||
|
||||
js_list = []
|
||||
handles = []
|
||||
idx = 0
|
||||
for ques_js, ans1_js, ans2_js in zip(f_q, f_ans1, f_ans2):
|
||||
# if idx == 1:
|
||||
# break
|
||||
|
||||
ques = json.loads(ques_js)
|
||||
ans1 = json.loads(ans1_js)
|
||||
ans2 = json.loads(ans2_js)
|
||||
|
||||
category = json.loads(ques_js)['category']
|
||||
if category in rule_dict:
|
||||
rule = rule_dict[category]
|
||||
else:
|
||||
rule = rule_dict['default']
|
||||
prompt = rule['prompt']
|
||||
role = rule['role']
|
||||
content = (f'[Question]\n{ques["text"]}\n\n'
|
||||
f'[{role} 1]\n{ans1["text"]}\n\n[End of {role} 1]\n\n'
|
||||
f'[{role} 2]\n{ans2["text"]}\n\n[End of {role} 2]\n\n'
|
||||
f'[System]\n{prompt}\n\n')
|
||||
js_list.append({
|
||||
'id': idx+1,
|
||||
'question_id': ques['question_id'],
|
||||
'answer1_id': ans1['answer_id'],
|
||||
'answer2_id': ans2['answer_id'],
|
||||
'category': category})
|
||||
idx += 1
|
||||
handles.append(get_eval.remote(content, args.max_tokens))
|
||||
# To avoid the rate limit set by OpenAI
|
||||
time.sleep(1)
|
||||
|
||||
reviews = ray.get(handles)
|
||||
for idx, review in enumerate(reviews):
|
||||
scores = parse_score(review)
|
||||
js_list[idx]['content'] = review
|
||||
js_list[idx]['tuple'] = scores
|
||||
review_file.write(json.dumps(js_list[idx]) + '\n')
|
||||
review_file.close()
|
||||
@@ -1,116 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
|
||||
import openai
|
||||
import tqdm
|
||||
import ray
|
||||
import time
|
||||
|
||||
@ray.remote(num_cpus=4)
|
||||
def get_eval(content: str, max_tokens: int):
|
||||
while True:
|
||||
try:
|
||||
response = openai.ChatCompletion.create(
|
||||
model='gpt-4',
|
||||
messages=[{
|
||||
'role': 'system',
|
||||
'content': 'You are a helpful and precise assistant for checking the quality of the answer.'
|
||||
}, {
|
||||
'role': 'user',
|
||||
'content': content,
|
||||
}],
|
||||
temperature=0.2, # TODO: figure out which temperature is best for evaluation
|
||||
max_tokens=max_tokens,
|
||||
)
|
||||
break
|
||||
except openai.error.RateLimitError:
|
||||
pass
|
||||
except Exception as e:
|
||||
print(e)
|
||||
time.sleep(1)
|
||||
|
||||
print('success!')
|
||||
return response['choices'][0]['message']['content']
|
||||
|
||||
|
||||
def parse_score(review):
|
||||
try:
|
||||
score_pair = review.split('\n')[0]
|
||||
score_pair = score_pair.replace(',', ' ')
|
||||
sp = score_pair.split(' ')
|
||||
if len(sp) == 2:
|
||||
return [float(sp[0]), float(sp[1])]
|
||||
else:
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
except Exception as e:
|
||||
print(e)
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
|
||||
parser.add_argument('-q', '--question')
|
||||
parser.add_argument('-c', '--context')
|
||||
parser.add_argument('-a', '--answer-list', nargs='+', default=[])
|
||||
parser.add_argument('-r', '--rule')
|
||||
parser.add_argument('-o', '--output')
|
||||
parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
|
||||
args = parser.parse_args()
|
||||
|
||||
ray.init()
|
||||
|
||||
f_q = open(os.path.expanduser(args.question))
|
||||
f_ans1 = open(os.path.expanduser(args.answer_list[0]))
|
||||
f_ans2 = open(os.path.expanduser(args.answer_list[1]))
|
||||
rule_dict = json.load(open(os.path.expanduser(args.rule), 'r'))
|
||||
|
||||
review_file = open(f'{args.output}', 'w')
|
||||
|
||||
context_list = [json.loads(line) for line in open(os.path.expanduser(args.context))]
|
||||
image_to_context = {context['image']: context for context in context_list}
|
||||
|
||||
js_list = []
|
||||
handles = []
|
||||
idx = 0
|
||||
for ques_js, ans1_js, ans2_js in zip(f_q, f_ans1, f_ans2):
|
||||
ques = json.loads(ques_js)
|
||||
ans1 = json.loads(ans1_js)
|
||||
ans2 = json.loads(ans2_js)
|
||||
|
||||
inst = image_to_context[ques['image']]
|
||||
cap_str = '\n'.join(inst['captions'])
|
||||
box_str = '\n'.join([f'{instance["category"]}: {instance["bbox"]}' for instance in inst['instances']])
|
||||
|
||||
category = json.loads(ques_js)['category']
|
||||
if category in rule_dict:
|
||||
rule = rule_dict[category]
|
||||
else:
|
||||
assert False, f"Visual QA category not found in rule file: {category}."
|
||||
prompt = rule['prompt']
|
||||
role = rule['role']
|
||||
content = (f'[Context]\n{cap_str}\n\n{box_str}\n\n'
|
||||
f'[Question]\n{ques["text"]}\n\n'
|
||||
f'[{role} 1]\n{ans1["text"]}\n\n[End of {role} 1]\n\n'
|
||||
f'[{role} 2]\n{ans2["text"]}\n\n[End of {role} 2]\n\n'
|
||||
f'[System]\n{prompt}\n\n')
|
||||
js_list.append({
|
||||
'id': idx+1,
|
||||
'question_id': ques['question_id'],
|
||||
'answer1_id': ans1.get('answer_id', ans1['question_id']),
|
||||
'answer2_id': ans2.get('answer_id', ans2['answer_id']),
|
||||
'category': category})
|
||||
idx += 1
|
||||
handles.append(get_eval.remote(content, args.max_tokens))
|
||||
# To avoid the rate limit set by OpenAI
|
||||
time.sleep(1)
|
||||
|
||||
reviews = ray.get(handles)
|
||||
for idx, review in enumerate(reviews):
|
||||
scores = parse_score(review)
|
||||
js_list[idx]['content'] = review
|
||||
js_list[idx]['tuple'] = scores
|
||||
review_file.write(json.dumps(js_list[idx]) + '\n')
|
||||
review_file.close()
|
||||
@@ -1,99 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import random
|
||||
|
||||
|
||||
def get_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--base-dir', type=str)
|
||||
parser.add_argument('--result-file', type=str)
|
||||
parser.add_argument('--output-file', type=str)
|
||||
parser.add_argument('--output-result', type=str)
|
||||
parser.add_argument('--split', type=str, default='test')
|
||||
parser.add_argument('--options', type=list, default=["A", "B", "C", "D", "E"])
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def convert_caps(results):
|
||||
fakecaps = []
|
||||
for result in results:
|
||||
image_id = result['question_id']
|
||||
caption = result['text']
|
||||
fakecaps.append({"image_id": int(image_id), "caption": caption})
|
||||
return fakecaps
|
||||
|
||||
|
||||
def get_pred_idx(prediction, choices, options):
|
||||
"""
|
||||
Get the index (e.g. 2) from the prediction (e.g. 'C')
|
||||
"""
|
||||
if prediction in options[:len(choices)]:
|
||||
return options.index(prediction)
|
||||
else:
|
||||
return random.choice(range(len(choices)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
args = get_args()
|
||||
|
||||
base_dir = args.base_dir
|
||||
split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[args.split]
|
||||
problems = json.load(open(os.path.join(base_dir, "problems.json")))
|
||||
predictions = [json.loads(line) for line in open(args.result_file)]
|
||||
predictions = {pred['question_id']: pred for pred in predictions}
|
||||
split_problems = {idx: problems[idx] for idx in split_indices}
|
||||
|
||||
results = {'correct': [], 'incorrect': []}
|
||||
sqa_results = {}
|
||||
sqa_results['acc'] = None
|
||||
sqa_results['correct'] = None
|
||||
sqa_results['count'] = None
|
||||
sqa_results['results'] = {}
|
||||
sqa_results['outputs'] = {}
|
||||
|
||||
for prob_id, prob in split_problems.items():
|
||||
if prob_id not in predictions:
|
||||
continue
|
||||
pred = predictions[prob_id]
|
||||
pred_text = pred['text']
|
||||
|
||||
pattern = re.compile(r'The answer is ([A-Z]).')
|
||||
res = pattern.findall(pred_text)
|
||||
if len(res) == 1:
|
||||
answer = res[0] # 'A', 'B', ...
|
||||
else:
|
||||
answer = "FAILED"
|
||||
|
||||
pred_idx = get_pred_idx(answer, prob['choices'], args.options)
|
||||
|
||||
analysis = {
|
||||
'question_id': prob_id,
|
||||
'parsed_ans': answer,
|
||||
'ground_truth': args.options[prob['answer']],
|
||||
'question': pred['prompt'],
|
||||
'pred': pred_text,
|
||||
'is_multimodal': '<image>' in pred['prompt'],
|
||||
}
|
||||
|
||||
sqa_results['results'][prob_id] = get_pred_idx(answer, prob['choices'], args.options)
|
||||
sqa_results['outputs'][prob_id] = pred_text
|
||||
|
||||
if pred_idx == prob['answer']:
|
||||
results['correct'].append(analysis)
|
||||
else:
|
||||
results['incorrect'].append(analysis)
|
||||
|
||||
correct = len(results['correct'])
|
||||
total = len(results['correct']) + len(results['incorrect'])
|
||||
print(f'Total: {total}, Correct: {correct}, Accuracy: {correct / total * 100:.2f}%')
|
||||
|
||||
sqa_results['acc'] = correct / total * 100
|
||||
sqa_results['correct'] = correct
|
||||
sqa_results['count'] = total
|
||||
|
||||
with open(args.output_file, 'w') as f:
|
||||
json.dump(results, f, indent=2)
|
||||
with open(args.output_result, 'w') as f:
|
||||
json.dump(sqa_results, f, indent=2)
|
||||
@@ -1,104 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import random
|
||||
from collections import defaultdict
|
||||
|
||||
|
||||
def get_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--base-dir', type=str)
|
||||
parser.add_argument('--gpt4-result', type=str)
|
||||
parser.add_argument('--our-result', type=str)
|
||||
parser.add_argument('--split', type=str, default='test')
|
||||
parser.add_argument('--options', type=list, default=["A", "B", "C", "D", "E"])
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def convert_caps(results):
|
||||
fakecaps = []
|
||||
for result in results:
|
||||
image_id = result['question_id']
|
||||
caption = result['text']
|
||||
fakecaps.append({"image_id": int(image_id), "caption": caption})
|
||||
return fakecaps
|
||||
|
||||
|
||||
def get_pred_idx(prediction, choices, options):
|
||||
"""
|
||||
Get the index (e.g. 2) from the prediction (e.g. 'C')
|
||||
"""
|
||||
if prediction in options[:len(choices)]:
|
||||
return options.index(prediction)
|
||||
else:
|
||||
return random.choice(range(len(choices)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
args = get_args()
|
||||
|
||||
base_dir = args.base_dir
|
||||
split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[args.split]
|
||||
problems = json.load(open(os.path.join(base_dir, "problems.json")))
|
||||
our_predictions = [json.loads(line) for line in open(args.our_result)]
|
||||
our_predictions = {pred['question_id']: pred for pred in our_predictions}
|
||||
split_problems = {idx: problems[idx] for idx in split_indices}
|
||||
|
||||
gpt4_predictions = json.load(open(args.gpt4_result))['outputs']
|
||||
|
||||
results = defaultdict(lambda: 0)
|
||||
|
||||
for prob_id, prob in split_problems.items():
|
||||
if prob_id not in our_predictions:
|
||||
continue
|
||||
if prob_id not in gpt4_predictions:
|
||||
continue
|
||||
our_pred = our_predictions[prob_id]['text']
|
||||
gpt4_pred = gpt4_predictions[prob_id]
|
||||
|
||||
pattern = re.compile(r'The answer is ([A-Z]).')
|
||||
our_res = pattern.findall(our_pred)
|
||||
if len(our_res) == 1:
|
||||
our_answer = our_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
our_answer = "FAILED"
|
||||
gpt4_res = pattern.findall(gpt4_pred)
|
||||
if len(gpt4_res) == 1:
|
||||
gpt4_answer = gpt4_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
gpt4_answer = "FAILED"
|
||||
|
||||
our_pred_idx = get_pred_idx(our_answer, prob['choices'], args.options)
|
||||
gpt4_pred_idx = get_pred_idx(gpt4_answer, prob['choices'], args.options)
|
||||
|
||||
if gpt4_answer == 'FAILED':
|
||||
results['gpt4_failed'] += 1
|
||||
# continue
|
||||
gpt4_pred_idx = our_pred_idx
|
||||
# if our_pred_idx != prob['answer']:
|
||||
# print(our_predictions[prob_id]['prompt'])
|
||||
# print('-----------------')
|
||||
# print(f'LECTURE: {prob["lecture"]}')
|
||||
# print(f'SOLUTION: {prob["solution"]}')
|
||||
# print('=====================')
|
||||
else:
|
||||
# continue
|
||||
pass
|
||||
# gpt4_pred_idx = our_pred_idx
|
||||
|
||||
if gpt4_pred_idx == prob['answer']:
|
||||
results['correct'] += 1
|
||||
else:
|
||||
results['incorrect'] += 1
|
||||
|
||||
|
||||
if gpt4_pred_idx == prob['answer'] or our_pred_idx == prob['answer']:
|
||||
results['correct_upperbound'] += 1
|
||||
|
||||
correct = results['correct']
|
||||
total = results['correct'] + results['incorrect']
|
||||
print(f'Total: {total}, Correct: {correct}, Accuracy: {correct / total * 100:.2f}%')
|
||||
print(f'Total: {total}, Correct (upper): {results["correct_upperbound"]}, Accuracy: {results["correct_upperbound"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4 NO-ANS (RANDOM): {results["gpt4_failed"]}, Percentage: {results["gpt4_failed"] / total * 100:.2f}%')
|
||||
|
||||
@@ -1,149 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import random
|
||||
from collections import defaultdict
|
||||
|
||||
|
||||
def get_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--base-dir', type=str)
|
||||
parser.add_argument('--gpt4-result', type=str)
|
||||
parser.add_argument('--requery-result', type=str)
|
||||
parser.add_argument('--our-result', type=str)
|
||||
parser.add_argument('--output-result', type=str)
|
||||
parser.add_argument('--split', type=str, default='test')
|
||||
parser.add_argument('--options', type=list, default=["A", "B", "C", "D", "E"])
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def convert_caps(results):
|
||||
fakecaps = []
|
||||
for result in results:
|
||||
image_id = result['question_id']
|
||||
caption = result['text']
|
||||
fakecaps.append({"image_id": int(image_id), "caption": caption})
|
||||
return fakecaps
|
||||
|
||||
|
||||
def get_pred_idx(prediction, choices, options):
|
||||
"""
|
||||
Get the index (e.g. 2) from the prediction (e.g. 'C')
|
||||
"""
|
||||
if prediction in options[:len(choices)]:
|
||||
return options.index(prediction)
|
||||
else:
|
||||
return random.choice(range(len(choices)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
args = get_args()
|
||||
|
||||
base_dir = args.base_dir
|
||||
split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[args.split]
|
||||
problems = json.load(open(os.path.join(base_dir, "problems.json")))
|
||||
our_predictions = [json.loads(line) for line in open(args.our_result)]
|
||||
our_predictions = {pred['question_id']: pred for pred in our_predictions}
|
||||
split_problems = {idx: problems[idx] for idx in split_indices}
|
||||
|
||||
requery_predictions = [json.loads(line) for line in open(args.requery_result)]
|
||||
requery_predictions = {pred['question_id']: pred for pred in requery_predictions}
|
||||
|
||||
gpt4_predictions = json.load(open(args.gpt4_result))['outputs']
|
||||
|
||||
results = defaultdict(lambda: 0)
|
||||
|
||||
sqa_results = {}
|
||||
sqa_results['acc'] = None
|
||||
sqa_results['correct'] = None
|
||||
sqa_results['count'] = None
|
||||
sqa_results['results'] = {}
|
||||
sqa_results['outputs'] = {}
|
||||
|
||||
for prob_id, prob in split_problems.items():
|
||||
if prob_id not in our_predictions:
|
||||
assert False
|
||||
if prob_id not in gpt4_predictions:
|
||||
assert False
|
||||
our_pred = our_predictions[prob_id]['text']
|
||||
gpt4_pred = gpt4_predictions[prob_id]
|
||||
if prob_id not in requery_predictions:
|
||||
results['missing_requery'] += 1
|
||||
requery_pred = "MISSING"
|
||||
else:
|
||||
requery_pred = requery_predictions[prob_id]['text']
|
||||
|
||||
pattern = re.compile(r'The answer is ([A-Z]).')
|
||||
our_res = pattern.findall(our_pred)
|
||||
if len(our_res) == 1:
|
||||
our_answer = our_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
our_answer = "FAILED"
|
||||
|
||||
requery_res = pattern.findall(requery_pred)
|
||||
if len(requery_res) == 1:
|
||||
requery_answer = requery_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
requery_answer = "FAILED"
|
||||
|
||||
gpt4_res = pattern.findall(gpt4_pred)
|
||||
if len(gpt4_res) == 1:
|
||||
gpt4_answer = gpt4_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
gpt4_answer = "FAILED"
|
||||
|
||||
our_pred_idx = get_pred_idx(our_answer, prob['choices'], args.options)
|
||||
gpt4_pred_idx = get_pred_idx(gpt4_answer, prob['choices'], args.options)
|
||||
requery_pred_idx = get_pred_idx(requery_answer, prob['choices'], args.options)
|
||||
|
||||
results['total'] += 1
|
||||
|
||||
if gpt4_answer == 'FAILED':
|
||||
results['gpt4_failed'] += 1
|
||||
if gpt4_pred_idx == prob['answer']:
|
||||
results['gpt4_correct'] += 1
|
||||
if our_pred_idx == prob['answer']:
|
||||
results['gpt4_ourvisual_correct'] += 1
|
||||
elif gpt4_pred_idx == prob['answer']:
|
||||
results['gpt4_correct'] += 1
|
||||
results['gpt4_ourvisual_correct'] += 1
|
||||
|
||||
if our_pred_idx == prob['answer']:
|
||||
results['our_correct'] += 1
|
||||
|
||||
if requery_answer == 'FAILED':
|
||||
sqa_results['results'][prob_id] = our_pred_idx
|
||||
if our_pred_idx == prob['answer']:
|
||||
results['requery_correct'] += 1
|
||||
else:
|
||||
sqa_results['results'][prob_id] = requery_pred_idx
|
||||
if requery_pred_idx == prob['answer']:
|
||||
results['requery_correct'] += 1
|
||||
else:
|
||||
print(f"""
|
||||
Question ({args.options[prob['answer']]}): {our_predictions[prob_id]['prompt']}
|
||||
Our ({our_answer}): {our_pred}
|
||||
GPT-4 ({gpt4_answer}): {gpt4_pred}
|
||||
Requery ({requery_answer}): {requery_pred}
|
||||
print("=====================================")
|
||||
""")
|
||||
|
||||
if gpt4_pred_idx == prob['answer'] or our_pred_idx == prob['answer']:
|
||||
results['correct_upperbound'] += 1
|
||||
|
||||
total = results['total']
|
||||
print(f'Total: {total}, Our-Correct: {results["our_correct"]}, Accuracy: {results["our_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4-Correct: {results["gpt4_correct"]}, Accuracy: {results["gpt4_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4 NO-ANS (RANDOM): {results["gpt4_failed"]}, Percentage: {results["gpt4_failed"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4-OursVisual-Correct: {results["gpt4_ourvisual_correct"]}, Accuracy: {results["gpt4_ourvisual_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, Requery-Correct: {results["requery_correct"]}, Accuracy: {results["requery_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, Correct upper: {results["correct_upperbound"]}, Accuracy: {results["correct_upperbound"] / total * 100:.2f}%')
|
||||
|
||||
sqa_results['acc'] = results["requery_correct"] / total * 100
|
||||
sqa_results['correct'] = results["requery_correct"]
|
||||
sqa_results['count'] = total
|
||||
|
||||
with open(args.output_result, 'w') as f:
|
||||
json.dump(sqa_results, f, indent=2)
|
||||
|
||||
@@ -1,111 +0,0 @@
|
||||
"""Generate json file for webpage."""
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
|
||||
# models = ['llama', 'alpaca', 'gpt35', 'bard']
|
||||
models = ['vicuna']
|
||||
|
||||
|
||||
def read_jsonl(path: str, key: str=None):
|
||||
data = []
|
||||
with open(os.path.expanduser(path)) as f:
|
||||
for line in f:
|
||||
if not line:
|
||||
continue
|
||||
data.append(json.loads(line))
|
||||
if key is not None:
|
||||
data.sort(key=lambda x: x[key])
|
||||
data = {item[key]: item for item in data}
|
||||
return data
|
||||
|
||||
|
||||
def trim_hanging_lines(s: str, n: int) -> str:
|
||||
s = s.strip()
|
||||
for _ in range(n):
|
||||
s = s.split('\n', 1)[1].strip()
|
||||
return s
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
questions = read_jsonl('table/question.jsonl', key='question_id')
|
||||
|
||||
# alpaca_answers = read_jsonl('table/answer/answer_alpaca-13b.jsonl', key='question_id')
|
||||
# bard_answers = read_jsonl('table/answer/answer_bard.jsonl', key='question_id')
|
||||
# gpt35_answers = read_jsonl('table/answer/answer_gpt35.jsonl', key='question_id')
|
||||
# llama_answers = read_jsonl('table/answer/answer_llama-13b.jsonl', key='question_id')
|
||||
vicuna_answers = read_jsonl('table/answer/answer_vicuna-13b.jsonl', key='question_id')
|
||||
ours_answers = read_jsonl('table/results/llama-13b-hf-alpaca.jsonl', key='question_id')
|
||||
|
||||
review_vicuna = read_jsonl('table/review/review_vicuna-13b_llama-13b-hf-alpaca.jsonl', key='question_id')
|
||||
# review_alpaca = read_jsonl('table/review/review_alpaca-13b_vicuna-13b.jsonl', key='question_id')
|
||||
# review_bard = read_jsonl('table/review/review_bard_vicuna-13b.jsonl', key='question_id')
|
||||
# review_gpt35 = read_jsonl('table/review/review_gpt35_vicuna-13b.jsonl', key='question_id')
|
||||
# review_llama = read_jsonl('table/review/review_llama-13b_vicuna-13b.jsonl', key='question_id')
|
||||
|
||||
records = []
|
||||
for qid in questions.keys():
|
||||
r = {
|
||||
'id': qid,
|
||||
'category': questions[qid]['category'],
|
||||
'question': questions[qid]['text'],
|
||||
'answers': {
|
||||
# 'alpaca': alpaca_answers[qid]['text'],
|
||||
# 'llama': llama_answers[qid]['text'],
|
||||
# 'bard': bard_answers[qid]['text'],
|
||||
# 'gpt35': gpt35_answers[qid]['text'],
|
||||
'vicuna': vicuna_answers[qid]['text'],
|
||||
'ours': ours_answers[qid]['text'],
|
||||
},
|
||||
'evaluations': {
|
||||
# 'alpaca': review_alpaca[qid]['text'],
|
||||
# 'llama': review_llama[qid]['text'],
|
||||
# 'bard': review_bard[qid]['text'],
|
||||
'vicuna': review_vicuna[qid]['content'],
|
||||
# 'gpt35': review_gpt35[qid]['text'],
|
||||
},
|
||||
'scores': {
|
||||
'vicuna': review_vicuna[qid]['tuple'],
|
||||
# 'alpaca': review_alpaca[qid]['score'],
|
||||
# 'llama': review_llama[qid]['score'],
|
||||
# 'bard': review_bard[qid]['score'],
|
||||
# 'gpt35': review_gpt35[qid]['score'],
|
||||
},
|
||||
}
|
||||
|
||||
# cleanup data
|
||||
cleaned_evals = {}
|
||||
for k, v in r['evaluations'].items():
|
||||
v = v.strip()
|
||||
lines = v.split('\n')
|
||||
# trim the first line if it's a pair of numbers
|
||||
if re.match(r'\d+[, ]+\d+', lines[0]):
|
||||
lines = lines[1:]
|
||||
v = '\n'.join(lines)
|
||||
cleaned_evals[k] = v.replace('Assistant 1', "**Assistant 1**").replace('Assistant 2', '**Assistant 2**')
|
||||
|
||||
r['evaluations'] = cleaned_evals
|
||||
records.append(r)
|
||||
|
||||
# Reorder the records, this is optional
|
||||
for r in records:
|
||||
if r['id'] <= 20:
|
||||
r['id'] += 60
|
||||
else:
|
||||
r['id'] -= 20
|
||||
for r in records:
|
||||
if r['id'] <= 50:
|
||||
r['id'] += 10
|
||||
elif 50 < r['id'] <= 60:
|
||||
r['id'] -= 50
|
||||
for r in records:
|
||||
if r['id'] == 7:
|
||||
r['id'] = 1
|
||||
elif r['id'] < 7:
|
||||
r['id'] += 1
|
||||
|
||||
records.sort(key=lambda x: x['id'])
|
||||
|
||||
# Write to file
|
||||
with open('webpage/data.json', 'w') as f:
|
||||
json.dump({'questions': records, 'models': models}, f, indent=2)
|
||||
@@ -1,84 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM, StoppingCriteria
|
||||
import torch
|
||||
import os
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
import shortuuid
|
||||
|
||||
from llava.conversation import default_conversation
|
||||
from llava.utils import disable_torch_init
|
||||
|
||||
|
||||
# new stopping implementation
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
@torch.inference_mode()
|
||||
def eval_model(model_name, questions_file, answers_file):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
model = AutoModelForCausalLM.from_pretrained(model_name,
|
||||
torch_dtype=torch.float16).cuda()
|
||||
|
||||
|
||||
ques_file = open(os.path.expanduser(questions_file), "r")
|
||||
ans_file = open(os.path.expanduser(answers_file), "w")
|
||||
for i, line in enumerate(tqdm(ques_file)):
|
||||
idx = json.loads(line)["question_id"]
|
||||
qs = json.loads(line)["text"]
|
||||
cat = json.loads(line)["category"]
|
||||
conv = default_conversation.copy()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
stopping_criteria = KeywordsStoppingCriteria([conv.sep], tokenizer, input_ids)
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]
|
||||
try:
|
||||
index = outputs.index(conv.sep, len(prompt))
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep, len(prompt))
|
||||
|
||||
outputs = outputs[len(prompt) + len(conv.roles[1]) + 2:index].strip()
|
||||
ans_id = shortuuid.uuid()
|
||||
ans_file.write(json.dumps({"question_id": idx,
|
||||
"text": outputs,
|
||||
"answer_id": ans_id,
|
||||
"model_id": model_name,
|
||||
"metadata": {}}) + "\n")
|
||||
ans_file.flush()
|
||||
ans_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--question-file", type=str, default="tables/question.jsonl")
|
||||
parser.add_argument("--answers-file", type=str, default="answer.jsonl")
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args.model_name, args.question_file, args.answers_file)
|
||||
@@ -1,207 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig
|
||||
import torch
|
||||
import os
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
import shortuuid
|
||||
|
||||
from llava import LlavaLlamaForCausalLM
|
||||
from llava.conversation import conv_templates
|
||||
from llava.utils import disable_torch_init
|
||||
from transformers import CLIPVisionModel, CLIPImageProcessor, StoppingCriteria
|
||||
|
||||
from PIL import Image
|
||||
import random
|
||||
import math
|
||||
|
||||
|
||||
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]
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
def patch_config(config):
|
||||
patch_dict = {
|
||||
"use_mm_proj": True,
|
||||
"mm_vision_tower": "openai/clip-vit-large-patch14",
|
||||
"mm_hidden_size": 1024
|
||||
}
|
||||
|
||||
cfg = AutoConfig.from_pretrained(config)
|
||||
if not hasattr(cfg, "mm_vision_tower"):
|
||||
print(f'`mm_vision_tower` not found in `{config}`, applying patch and save to disk.')
|
||||
for k, v in patch_dict.items():
|
||||
setattr(cfg, k, v)
|
||||
cfg.save_pretrained(config)
|
||||
|
||||
|
||||
def eval_model(args):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(args.model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
if args.mm_projector is None:
|
||||
patch_config(model_name)
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.model.vision_tower[0]
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
else:
|
||||
# in case of using a pretrained model with only a MLP projector weights
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16).cuda()
|
||||
|
||||
vision_tower = CLIPVisionModel.from_pretrained(args.vision_tower, torch_dtype=torch.float16).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(args.vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
mm_projector = torch.nn.Linear(vision_config.hidden_size, model.config.hidden_size)
|
||||
mm_projector_weights = torch.load(args.mm_projector, map_location='cpu')
|
||||
mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items()})
|
||||
|
||||
model.model.mm_projector = mm_projector.cuda().half()
|
||||
model.model.vision_tower = [vision_tower]
|
||||
|
||||
questions = [json.loads(q) for q in open(os.path.expanduser(args.question_file), "r")]
|
||||
questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
|
||||
answers_file = os.path.expanduser(args.answers_file)
|
||||
os.makedirs(os.path.dirname(answers_file), exist_ok=True)
|
||||
ans_file = open(answers_file, "w")
|
||||
for i, line in enumerate(tqdm(questions)):
|
||||
idx = line["question_id"]
|
||||
image_file = line["image"]
|
||||
qs = line["text"]
|
||||
cur_prompt = qs
|
||||
if mm_use_im_start_end:
|
||||
qs = qs + '\n' + DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len + DEFAULT_IM_END_TOKEN
|
||||
else:
|
||||
qs = qs + '\n' + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
|
||||
if args.conv_mode == 'simple_legacy':
|
||||
qs += '\n\n### Response:'
|
||||
# conv = default_conversation.copy()
|
||||
conv = conv_templates[args.conv_mode].copy()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
|
||||
image = Image.open(os.path.join(args.image_folder, image_file))
|
||||
# image.save(os.path.join(save_image_folder, image_file))
|
||||
image_tensor = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
# new stopping implementation
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
|
||||
keywords = ['###']
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=image_tensor.unsqueeze(0).half().cuda(),
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] Sample {i}: {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
|
||||
if args.conv_mode == 'simple_legacy' or args.conv_mode == 'simple':
|
||||
while True:
|
||||
cur_len = len(outputs)
|
||||
outputs = outputs.strip()
|
||||
for pattern in ['###', 'Assistant:', 'Response:']:
|
||||
if outputs.startswith(pattern):
|
||||
outputs = outputs[len(pattern):].strip()
|
||||
if len(outputs) == cur_len:
|
||||
break
|
||||
|
||||
try:
|
||||
index = outputs.index(conv.sep)
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep)
|
||||
|
||||
outputs = outputs[:index].strip()
|
||||
|
||||
ans_id = shortuuid.uuid()
|
||||
ans_file.write(json.dumps({"question_id": idx,
|
||||
"prompt": cur_prompt,
|
||||
"text": outputs,
|
||||
"answer_id": ans_id,
|
||||
"model_id": model_name,
|
||||
"metadata": {}}) + "\n")
|
||||
ans_file.flush()
|
||||
ans_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--image-folder", type=str, default="")
|
||||
parser.add_argument("--question-file", type=str, default="tables/question.jsonl")
|
||||
parser.add_argument("--answers-file", type=str, default="answer.jsonl")
|
||||
parser.add_argument("--mm-projector", type=str, default=None)
|
||||
parser.add_argument("--vision-tower", type=str, default=None)
|
||||
parser.add_argument("--conv-mode", type=str, default="simple")
|
||||
parser.add_argument("--num-chunks", type=int, default=1)
|
||||
parser.add_argument("--chunk-idx", type=int, default=0)
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args)
|
||||
@@ -1,309 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig
|
||||
import torch
|
||||
import os
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
import shortuuid
|
||||
|
||||
from llava import LlavaLlamaForCausalLM
|
||||
from llava.conversation import conv_templates
|
||||
from llava.utils import disable_torch_init
|
||||
from transformers import CLIPVisionModel, CLIPImageProcessor, StoppingCriteria
|
||||
|
||||
from PIL import Image
|
||||
import random
|
||||
import math
|
||||
|
||||
|
||||
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]
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
|
||||
|
||||
detail_describe_instructions = [
|
||||
"Describe the following image in detail.",
|
||||
"Provide a detailed description of the given image.",
|
||||
"Give an elaborate explanation of the image you see.",
|
||||
"Share a comprehensive rundown of the presented image.",
|
||||
"Offer a thorough analysis of the image.",
|
||||
"Explain the various aspects of the image before you.",
|
||||
"Clarify the contents of the displayed image with great detail.",
|
||||
"Characterize the image using a well-detailed description.",
|
||||
"Break down the elements of the image in a detailed manner.",
|
||||
"Walk through the important details of the image.",
|
||||
"Portray the image with a rich, descriptive narrative.",
|
||||
"Narrate the contents of the image with precision.",
|
||||
"Analyze the image in a comprehensive and detailed manner.",
|
||||
"Illustrate the image through a descriptive explanation.",
|
||||
"Examine the image closely and share its details.",
|
||||
"Write an exhaustive depiction of the given image.",
|
||||
]
|
||||
|
||||
concise_describe_instructions = [
|
||||
"Describe the following image concisely.",
|
||||
"Provide a brief description of the given image.",
|
||||
"Offer a succinct explanation of the picture presented.",
|
||||
"Summarize the visual content of the following image.",
|
||||
"Give a short and clear explanation of the subsequent image.",
|
||||
"Share a concise interpretation of the image provided.",
|
||||
"Present a compact description of the photo's key features.",
|
||||
"Relay a brief, clear account of the picture shown.",
|
||||
"Render a clear and concise summary of the photo below.",
|
||||
"Write a terse but informative summary of the following picture.",
|
||||
"Create a compact narrative representing the image presented.",
|
||||
]
|
||||
|
||||
prompt_pool = detail_describe_instructions + concise_describe_instructions
|
||||
|
||||
prompt_pool = [ "Describe the following image in detail."]
|
||||
|
||||
|
||||
def patch_config(config):
|
||||
patch_dict = {
|
||||
"use_mm_proj": True,
|
||||
"mm_vision_tower": "openai/clip-vit-large-patch14",
|
||||
"mm_hidden_size": 1024
|
||||
}
|
||||
|
||||
cfg = AutoConfig.from_pretrained(config)
|
||||
if not hasattr(cfg, "mm_vision_tower"):
|
||||
print(f'`mm_vision_tower` not found in `{config}`, applying patch and save to disk.')
|
||||
for k, v in patch_dict.items():
|
||||
setattr(cfg, k, v)
|
||||
cfg.save_pretrained(config)
|
||||
|
||||
|
||||
# new stopping implementation
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def eval_model(args):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(args.model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
if args.mm_projector is None:
|
||||
patch_config(model_name)
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.model.vision_tower[0]
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
else:
|
||||
# in case of using a pretrained model with only a MLP projector weights
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = CLIPVisionModel.from_pretrained(args.vision_tower, torch_dtype=torch.float16).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(args.vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
mm_projector = torch.nn.Linear(vision_config.hidden_size, model.config.hidden_size)
|
||||
mm_projector_weights = torch.load(args.mm_projector, map_location='cpu')
|
||||
mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items()})
|
||||
|
||||
model.model.mm_projector = mm_projector.cuda().half()
|
||||
model.model.vision_tower = [vision_tower]
|
||||
|
||||
questions = json.load(open(os.path.expanduser(args.question_file), "r"))
|
||||
questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
|
||||
answers_file = os.path.expanduser(args.answers_file)
|
||||
os.makedirs(os.path.dirname(answers_file), exist_ok=True)
|
||||
os.makedirs(os.path.join(os.path.dirname(answers_file), "images"), exist_ok=True)
|
||||
ans_file = open(answers_file, "w")
|
||||
save_image_folder = os.path.join(os.path.dirname(os.path.expanduser(args.answers_file)), "images")
|
||||
for i, line in enumerate(tqdm(questions)):
|
||||
idx = line["id"]
|
||||
question = line['conversations'][0]
|
||||
gt_ans = line["conversations"][1]
|
||||
|
||||
qs = question['value']
|
||||
|
||||
qs = qs.replace('<image>', '').strip()
|
||||
cur_prompt = qs
|
||||
|
||||
if 'image' in line:
|
||||
image_file = line["image"]
|
||||
image = Image.open(os.path.join(args.image_folder, image_file))
|
||||
image_tensor = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
|
||||
images = image_tensor.unsqueeze(0).half().cuda()
|
||||
if getattr(model.config, 'mm_use_im_start_end', False):
|
||||
qs = qs + '\n' + DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len + DEFAULT_IM_END_TOKEN
|
||||
else:
|
||||
qs = qs + '\n' + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
cur_prompt = cur_prompt + '\n' + '<image>'
|
||||
else:
|
||||
images = None
|
||||
|
||||
if args.conv_mode == 'simple_legacy':
|
||||
qs += '\n\n### Response:'
|
||||
assert gt_ans['from'] == 'gpt'
|
||||
# conv = default_conversation.copy()
|
||||
conv = conv_templates[args.conv_mode].copy()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
keywords = ['###']
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=images,
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
# TODO: new implementation
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] Sample {i}: {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
|
||||
if args.conv_mode == 'simple_legacy':
|
||||
while True:
|
||||
cur_len = len(outputs)
|
||||
outputs = outputs.strip()
|
||||
for pattern in ['###', 'Assistant:', 'Response:']:
|
||||
if outputs.startswith(pattern):
|
||||
outputs = outputs[len(pattern):].strip()
|
||||
if len(outputs) == cur_len:
|
||||
break
|
||||
|
||||
try:
|
||||
index = outputs.index(conv.sep)
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep)
|
||||
|
||||
outputs = outputs[:index].strip()
|
||||
|
||||
# prompt for answer
|
||||
if args.answer_prompter:
|
||||
outputs_reasoning = outputs
|
||||
inputs = tokenizer([prompt + outputs_reasoning + ' ###\nANSWER:'])
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
keywords = ['###']
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=images,
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=64,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] Sample {i}: {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
|
||||
try:
|
||||
index = outputs.index(conv.sep)
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep)
|
||||
|
||||
outputs = outputs[:index].strip()
|
||||
outputs = outputs_reasoning + '\n The answer is ' + outputs
|
||||
|
||||
# new implementation ends
|
||||
|
||||
# original implementation
|
||||
# outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]
|
||||
# try:
|
||||
# index = outputs.index(conv.sep, len(prompt))
|
||||
# except ValueError:
|
||||
# outputs += conv.sep
|
||||
# index = outputs.index(conv.sep, len(prompt))
|
||||
|
||||
# outputs = outputs[len(prompt) + len(conv.roles[1]) + 2:index].strip()
|
||||
|
||||
|
||||
ans_id = shortuuid.uuid()
|
||||
ans_file.write(json.dumps({"question_id": idx,
|
||||
"prompt": cur_prompt,
|
||||
"text": outputs,
|
||||
"answer_id": ans_id,
|
||||
"model_id": model_name,
|
||||
"metadata": {}}) + "\n")
|
||||
ans_file.flush()
|
||||
ans_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--image-folder", type=str, default="")
|
||||
parser.add_argument("--question-file", type=str, default="tables/question.json")
|
||||
parser.add_argument("--answers-file", type=str, default="answer.jsonl")
|
||||
parser.add_argument("--mm-projector", type=str, default=None)
|
||||
parser.add_argument("--vision-tower", type=str, default=None)
|
||||
parser.add_argument("--conv-mode", type=str, default="simple")
|
||||
parser.add_argument("--num-chunks", type=int, default=1)
|
||||
parser.add_argument("--chunk-idx", type=int, default=0)
|
||||
parser.add_argument("--answer-prompter", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args)
|
||||
@@ -1,74 +0,0 @@
|
||||
"""Generate answers with GPT-3.5"""
|
||||
# Note: you need to be using OpenAI Python v0.27.0 for the code below to work
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
import concurrent.futures
|
||||
|
||||
import openai
|
||||
import tqdm
|
||||
import shortuuid
|
||||
|
||||
MODEL = 'gpt-3.5-turbo'
|
||||
MODEL_ID = 'gpt-3.5-turbo:20230327'
|
||||
|
||||
def get_answer(question_id: int, question: str, max_tokens: int):
|
||||
ans = {
|
||||
'answer_id': shortuuid.uuid(),
|
||||
'question_id': question_id,
|
||||
'model_id': MODEL_ID,
|
||||
}
|
||||
for _ in range(3):
|
||||
try:
|
||||
response = openai.ChatCompletion.create(
|
||||
model=MODEL,
|
||||
messages=[{
|
||||
'role': 'system',
|
||||
'content': 'You are a helpful assistant.'
|
||||
}, {
|
||||
'role': 'user',
|
||||
'content': question,
|
||||
}],
|
||||
max_tokens=max_tokens,
|
||||
)
|
||||
ans['text'] = response['choices'][0]['message']['content']
|
||||
return ans
|
||||
except Exception as e:
|
||||
print('[ERROR]', e)
|
||||
ans['text'] = '#ERROR#'
|
||||
time.sleep(1)
|
||||
return ans
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description='ChatGPT answer generation.')
|
||||
parser.add_argument('-q', '--question')
|
||||
parser.add_argument('-o', '--output')
|
||||
parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
|
||||
args = parser.parse_args()
|
||||
|
||||
questions_dict = {}
|
||||
with open(os.path.expanduser(args.question)) as f:
|
||||
for line in f:
|
||||
if not line:
|
||||
continue
|
||||
q = json.loads(line)
|
||||
questions_dict[q['question_id']] = q['text']
|
||||
|
||||
answers = []
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=32) as executor:
|
||||
futures = []
|
||||
for qid, question in questions_dict.items():
|
||||
future = executor.submit(get_answer, qid, question, args.max_tokens)
|
||||
futures.append(future)
|
||||
|
||||
for future in tqdm.tqdm(concurrent.futures.as_completed(futures), total=len(futures)):
|
||||
answers.append(future.result())
|
||||
|
||||
answers.sort(key=lambda x: x['question_id'])
|
||||
|
||||
with open(os.path.expanduser(args.output), 'w') as f:
|
||||
table = [json.dumps(ans) for ans in answers]
|
||||
f.write('\n'.join(table))
|
||||
@@ -1,125 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
import torch
|
||||
import os
|
||||
from llava.conversation import conv_templates, SeparatorStyle
|
||||
from llava.utils import disable_torch_init
|
||||
from transformers import CLIPVisionModel, CLIPImageProcessor, StoppingCriteria
|
||||
from llava.model import *
|
||||
from llava.model.utils import KeywordsStoppingCriteria
|
||||
|
||||
from PIL import Image
|
||||
|
||||
import os
|
||||
import requests
|
||||
from PIL import Image
|
||||
from io import BytesIO
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
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 eval_model(args):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(args.model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
|
||||
if "mpt" in model_name.lower():
|
||||
model = LlavaMPTForCausalLM.from_pretrained(model_name, low_cpu_mem_usage=True, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
else:
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, low_cpu_mem_usage=True, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.get_model().vision_tower[0]
|
||||
if vision_tower.device.type == 'meta':
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower.config._name_or_path, torch_dtype=torch.float16, low_cpu_mem_usage=True).cuda()
|
||||
model.get_model().vision_tower[0] = vision_tower
|
||||
else:
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
qs = args.query
|
||||
if mm_use_im_start_end:
|
||||
qs = qs + '\n' + DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len + DEFAULT_IM_END_TOKEN
|
||||
else:
|
||||
qs = qs + '\n' + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
|
||||
if "v1" in model_name.lower():
|
||||
conv_mode = "llava_v1"
|
||||
elif "mpt" in model_name.lower():
|
||||
conv_mode = "mpt_multimodal"
|
||||
else:
|
||||
conv_mode = "multimodal"
|
||||
|
||||
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()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
conv.append_message(conv.roles[1], None)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
|
||||
image = load_image(args.image_file)
|
||||
image_tensor = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
|
||||
keywords = [stop_str]
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=image_tensor.unsqueeze(0).half().cuda(),
|
||||
do_sample=True,
|
||||
temperature=0.2,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
outputs = outputs.strip()
|
||||
if outputs.endswith(stop_str):
|
||||
outputs = outputs[:-len(stop_str)]
|
||||
outputs = outputs.strip()
|
||||
print(outputs)
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--image-file", type=str, required=True)
|
||||
parser.add_argument("--query", type=str, required=True)
|
||||
parser.add_argument("--conv-mode", type=str, default=None)
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args)
|
||||
@@ -1,26 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
from collections import defaultdict
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
base_dir = "vqa/reviews/coco2014_val80"
|
||||
review_files = [x for x in os.listdir(base_dir) if x.endswith('.jsonl') and x.startswith('gpt4_text')]
|
||||
|
||||
for review_file in sorted(review_files):
|
||||
config = review_file.replace('gpt4_text_', '').replace('.jsonl', '')
|
||||
scores = defaultdict(list)
|
||||
print(f'GPT-4 vs. {config}')
|
||||
with open(os.path.join(base_dir, review_file)) as f:
|
||||
for review_str in f:
|
||||
review = json.loads(review_str)
|
||||
scores[review['category']].append(review['tuple'])
|
||||
scores['all'].append(review['tuple'])
|
||||
for k, v in scores.items():
|
||||
stats = np.asarray(v).mean(0).tolist()
|
||||
stats = [round(x, 3) for x in stats]
|
||||
print(k, stats, round(stats[1]/stats[0]*100, 1))
|
||||
print('=================================')
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
from .llava import LlavaLlamaForCausalLM, LlavaConfig
|
||||
from .llava_mpt import LlavaMPTForCausalLM, LlavaMPTConfig
|
||||
@@ -1,48 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.model.apply_delta --base ~/model_weights/llama-7b --target ~/model_weights/vicuna-7b --delta lmsys/vicuna-7b-delta
|
||||
"""
|
||||
import argparse
|
||||
|
||||
import torch
|
||||
from tqdm import tqdm
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
from llava import LlavaLlamaForCausalLM
|
||||
|
||||
|
||||
def apply_delta(base_model_path, target_model_path, delta_path):
|
||||
print("Loading base model")
|
||||
base = AutoModelForCausalLM.from_pretrained(
|
||||
base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
|
||||
print("Loading delta")
|
||||
delta = LlavaLlamaForCausalLM.from_pretrained(delta_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
delta_tokenizer = AutoTokenizer.from_pretrained(delta_path)
|
||||
|
||||
print("Applying delta")
|
||||
for name, param in tqdm(delta.state_dict().items(), desc="Applying delta"):
|
||||
if name not in base.state_dict():
|
||||
assert name in ['model.mm_projector.weight', 'model.mm_projector.bias'], f'{name} not in base model'
|
||||
continue
|
||||
if param.data.shape == base.state_dict()[name].shape:
|
||||
param.data += base.state_dict()[name]
|
||||
else:
|
||||
assert name in ['model.embed_tokens.weight', 'lm_head.weight'], \
|
||||
f'{name} dimension mismatch: {param.data.shape} vs {base.state_dict()[name].shape}'
|
||||
bparam = base.state_dict()[name]
|
||||
param.data[:bparam.shape[0], :bparam.shape[1]] += bparam
|
||||
|
||||
print("Saving target model")
|
||||
delta.save_pretrained(target_model_path)
|
||||
delta_tokenizer.save_pretrained(target_model_path)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-model-path", type=str, required=True)
|
||||
parser.add_argument("--target-model-path", type=str, required=True)
|
||||
parser.add_argument("--delta-path", type=str, required=True)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
apply_delta(args.base_model_path, args.target_model_path, args.delta_path)
|
||||
@@ -1,29 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m llava.model.consolidate --src ~/model_weights/llava-7b --dst ~/model_weights/llava-7b_consolidate
|
||||
"""
|
||||
import argparse
|
||||
|
||||
import torch
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
from llava.model import *
|
||||
from llava.model.utils import auto_upgrade
|
||||
|
||||
|
||||
def consolidate_ckpt(src_path, dst_path):
|
||||
print("Loading model")
|
||||
auto_upgrade(src_path)
|
||||
src_model = AutoModelForCausalLM.from_pretrained(src_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
src_tokenizer = AutoTokenizer.from_pretrained(src_path)
|
||||
src_model.save_pretrained(dst_path)
|
||||
src_tokenizer.save_pretrained(dst_path)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--src", type=str, required=True)
|
||||
parser.add_argument("--dst", type=str, required=True)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
consolidate_ckpt(args.src, args.dst)
|
||||
@@ -1,330 +0,0 @@
|
||||
# Copyright 2023 Haotian Liu
|
||||
#
|
||||
# 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 typing import List, Optional, Tuple, Union
|
||||
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
from torch.nn import CrossEntropyLoss
|
||||
|
||||
from transformers import AutoConfig, AutoModelForCausalLM, \
|
||||
LlamaConfig, LlamaModel, LlamaForCausalLM, \
|
||||
CLIPVisionModel, CLIPImageProcessor
|
||||
|
||||
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
class LlavaConfig(LlamaConfig):
|
||||
model_type = "llava"
|
||||
|
||||
|
||||
class LlavaLlamaModel(LlamaModel):
|
||||
config_class = LlavaConfig
|
||||
|
||||
def __init__(self, config: LlamaConfig, mm_vision_tower=None, mm_hidden_size=None):
|
||||
super(LlavaLlamaModel, self).__init__(config)
|
||||
|
||||
if hasattr(config, "mm_vision_tower"):
|
||||
# HACK: for FSDP
|
||||
self.vision_tower = [CLIPVisionModel.from_pretrained(config.mm_vision_tower)]
|
||||
# self.vision_tower = CLIPVisionModel.from_pretrained(config.mm_vision_tower)
|
||||
|
||||
if hasattr(config, "use_mm_proj"):
|
||||
self.mm_projector = nn.Linear(config.mm_hidden_size, config.hidden_size)
|
||||
|
||||
def initialize_vision_modules(self, vision_tower, mm_vision_select_layer,
|
||||
pretrain_mm_mlp_adapter=None, tune_mm_mlp_adapter=False):
|
||||
self.config.mm_vision_tower = vision_tower
|
||||
|
||||
image_processor = CLIPImageProcessor.from_pretrained(vision_tower)
|
||||
|
||||
if not hasattr(self, 'vision_tower'):
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower)
|
||||
else:
|
||||
vision_tower = self.vision_tower[0]
|
||||
vision_tower.requires_grad_(False)
|
||||
vision_tower = vision_tower.to(torch.float16)
|
||||
self.vision_tower = [vision_tower]
|
||||
|
||||
vision_config = vision_tower.config
|
||||
num_patches = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
self.config.use_mm_proj = True
|
||||
self.config.mm_hidden_size = vision_config.hidden_size
|
||||
self.config.mm_vision_select_layer = mm_vision_select_layer
|
||||
|
||||
if not hasattr(self, 'mm_projector'):
|
||||
self.mm_projector = nn.Linear(vision_config.hidden_size, self.config.hidden_size)
|
||||
|
||||
if pretrain_mm_mlp_adapter is not None:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
self.mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items()})
|
||||
|
||||
return dict(
|
||||
image_processor=image_processor,
|
||||
image_token_len=num_patches,
|
||||
vision_config=vision_config
|
||||
)
|
||||
|
||||
def forward(
|
||||
self,
|
||||
input_ids: torch.LongTensor = None,
|
||||
attention_mask: Optional[torch.Tensor] = None,
|
||||
past_key_values: Optional[List[torch.FloatTensor]] = None,
|
||||
inputs_embeds: Optional[torch.FloatTensor] = None,
|
||||
use_cache: Optional[bool] = None,
|
||||
output_attentions: Optional[bool] = None,
|
||||
output_hidden_states: Optional[bool] = None,
|
||||
images: Optional[torch.FloatTensor] = None,
|
||||
return_dict: Optional[bool] = None,
|
||||
) -> Union[Tuple, BaseModelOutputWithPast]:
|
||||
|
||||
# HACK: replace back original embeddings for LLaVA pretraining
|
||||
orig_embeds_params = getattr(self, 'orig_embeds_params', None)
|
||||
# if orig_embeds_params is not None:
|
||||
# orig_embeds_params = orig_embeds_params[0]
|
||||
# with torch.no_grad():
|
||||
# self.get_input_embeddings().weight.data[:-2] = orig_embeds_params[:-2].data
|
||||
|
||||
if inputs_embeds is None:
|
||||
inputs_embeds = self.embed_tokens(input_ids)
|
||||
|
||||
vision_tower = getattr(self, 'vision_tower', None)
|
||||
if vision_tower is not None and (input_ids.shape[1] != 1 or self.training) and images is not None:
|
||||
# TODO: this is a modified multimodal LLM -- Haotian Liu
|
||||
vision_tower = vision_tower[0] # HACK: for FSDP
|
||||
with torch.no_grad():
|
||||
if type(images) is list:
|
||||
# variable length images
|
||||
image_features = []
|
||||
for image in images:
|
||||
image_forward_out = vision_tower(image.unsqueeze(0), output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_out.hidden_states[select_hidden_state_layer]
|
||||
image_feature = select_hidden_state[:, 1:]
|
||||
image_features.append(image_feature)
|
||||
else:
|
||||
image_forward_outs = vision_tower(images, output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_outs.hidden_states[select_hidden_state_layer]
|
||||
image_features = select_hidden_state[:, 1:]
|
||||
if type(images) is list:
|
||||
image_features = [self.mm_projector(image_feature)[0] for image_feature in image_features]
|
||||
else:
|
||||
image_features = self.mm_projector(image_features)
|
||||
dummy_image_features = torch.zeros(256, 1024, device=inputs_embeds.device, dtype=inputs_embeds.dtype)
|
||||
dummy_image_features = self.mm_projector(dummy_image_features)
|
||||
|
||||
new_input_embeds = []
|
||||
cur_image_idx = 0
|
||||
for cur_input_ids, cur_input_embeds in zip(input_ids, inputs_embeds):
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() == 0:
|
||||
# multimodal LLM, but the current sample is not multimodal
|
||||
cur_input_embeds = cur_input_embeds + (0. * dummy_image_features).sum()
|
||||
new_input_embeds.append(cur_input_embeds)
|
||||
cur_image_idx += 1
|
||||
continue
|
||||
if vision_tower.config.use_im_start_end:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_start_token).sum() != (cur_input_ids == vision_tower.config.im_end_token).sum():
|
||||
raise ValueError("The number of image start tokens and image end tokens should be the same.")
|
||||
image_start_tokens = torch.where(cur_input_ids == vision_tower.config.im_start_token)[0]
|
||||
for image_start_token_pos in image_start_tokens:
|
||||
cur_image_features = image_features[cur_image_idx].to(device=cur_input_embeds.device)
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if cur_input_ids[image_start_token_pos + num_patches + 1] != vision_tower.config.im_end_token:
|
||||
raise ValueError("The image end token should follow the image start token.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos].detach(), cur_input_embeds[image_start_token_pos:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:image_start_token_pos + num_patches + 2], cur_input_embeds[image_start_token_pos + num_patches + 2:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:]), dim=0)
|
||||
cur_image_idx += 1
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
else:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() != num_patches:
|
||||
raise ValueError("The number of image patch tokens should be the same as the number of image patches.")
|
||||
masked_indices = torch.where(cur_input_ids == vision_tower.config.im_patch_token)[0]
|
||||
mask_index_start = masked_indices[0]
|
||||
if (masked_indices != torch.arange(mask_index_start, mask_index_start+num_patches, device=masked_indices.device, dtype=masked_indices.dtype)).any():
|
||||
raise ValueError("The image patch tokens should be consecutive.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start].detach(), cur_image_features, cur_input_embeds[mask_index_start+num_patches:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start], cur_image_features, cur_input_embeds[mask_index_start+num_patches:]), dim=0)
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
cur_image_idx += 1
|
||||
inputs_embeds = torch.stack(new_input_embeds, dim=0)
|
||||
|
||||
return super(LlavaLlamaModel, self).forward(
|
||||
input_ids=None, attention_mask=attention_mask, past_key_values=past_key_values,
|
||||
inputs_embeds=inputs_embeds, use_cache=use_cache,
|
||||
output_attentions=output_attentions, output_hidden_states=output_hidden_states,
|
||||
return_dict=return_dict
|
||||
)
|
||||
|
||||
|
||||
class LlavaLlamaForCausalLM(LlamaForCausalLM):
|
||||
config_class = LlavaConfig
|
||||
|
||||
def __init__(self, config):
|
||||
super(LlamaForCausalLM, self).__init__(config)
|
||||
self.model = LlavaLlamaModel(config)
|
||||
|
||||
self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
|
||||
|
||||
# Initialize weights and apply final processing
|
||||
self.post_init()
|
||||
|
||||
def get_model(self):
|
||||
return self.model
|
||||
|
||||
def forward(
|
||||
self,
|
||||
input_ids: torch.LongTensor = None,
|
||||
attention_mask: Optional[torch.Tensor] = None,
|
||||
past_key_values: Optional[List[torch.FloatTensor]] = None,
|
||||
inputs_embeds: Optional[torch.FloatTensor] = None,
|
||||
labels: Optional[torch.LongTensor] = None,
|
||||
use_cache: Optional[bool] = None,
|
||||
output_attentions: Optional[bool] = None,
|
||||
output_hidden_states: Optional[bool] = None,
|
||||
images: Optional[torch.FloatTensor] = None,
|
||||
return_dict: Optional[bool] = None,
|
||||
) -> Union[Tuple, CausalLMOutputWithPast]:
|
||||
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
|
||||
|
||||
# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
|
||||
outputs = self.model(
|
||||
input_ids=input_ids,
|
||||
attention_mask=attention_mask,
|
||||
past_key_values=past_key_values,
|
||||
inputs_embeds=inputs_embeds,
|
||||
use_cache=use_cache,
|
||||
output_attentions=output_attentions,
|
||||
output_hidden_states=output_hidden_states,
|
||||
return_dict=return_dict,
|
||||
images=images
|
||||
)
|
||||
|
||||
hidden_states = outputs[0]
|
||||
logits = self.lm_head(hidden_states)
|
||||
|
||||
loss = None
|
||||
if labels is not None:
|
||||
# Shift so that tokens < n predict n
|
||||
shift_logits = logits[..., :-1, :].contiguous()
|
||||
shift_labels = labels[..., 1:].contiguous()
|
||||
# Flatten the tokens
|
||||
loss_fct = CrossEntropyLoss()
|
||||
shift_logits = shift_logits.view(-1, self.config.vocab_size)
|
||||
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)
|
||||
|
||||
if not return_dict:
|
||||
output = (logits,) + outputs[1:]
|
||||
return (loss,) + output if loss is not None else output
|
||||
|
||||
return CausalLMOutputWithPast(
|
||||
loss=loss,
|
||||
logits=logits,
|
||||
past_key_values=outputs.past_key_values,
|
||||
hidden_states=outputs.hidden_states,
|
||||
attentions=outputs.attentions,
|
||||
)
|
||||
|
||||
def prepare_inputs_for_generation(
|
||||
self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
|
||||
):
|
||||
if past_key_values:
|
||||
input_ids = input_ids[:, -1:]
|
||||
|
||||
# if `inputs_embeds` are passed, we only want to use them in the 1st generation step
|
||||
if inputs_embeds is not None and past_key_values is None:
|
||||
model_inputs = {"inputs_embeds": inputs_embeds}
|
||||
else:
|
||||
model_inputs = {"input_ids": input_ids}
|
||||
|
||||
model_inputs.update(
|
||||
{
|
||||
"past_key_values": past_key_values,
|
||||
"use_cache": kwargs.get("use_cache"),
|
||||
"attention_mask": attention_mask,
|
||||
"images": kwargs.get("images", None),
|
||||
}
|
||||
)
|
||||
return model_inputs
|
||||
|
||||
def initialize_vision_tokenizer(self, mm_use_im_start_end, tokenizer, device,
|
||||
tune_mm_mlp_adapter=False, pretrain_mm_mlp_adapter=None):
|
||||
vision_config = self.get_model().vision_tower[0].config
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
|
||||
if mm_use_im_start_end:
|
||||
num_new_tokens = tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
if num_new_tokens > 0:
|
||||
input_embeddings = self.get_input_embeddings().weight.data
|
||||
output_embeddings = self.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
|
||||
|
||||
if tune_mm_mlp_adapter:
|
||||
self.get_model().orig_embeds_params = [self.get_input_embeddings().weight.data.clone().to(device=device)]
|
||||
for p in self.get_input_embeddings().parameters():
|
||||
p.requires_grad = True
|
||||
for p in self.get_output_embeddings().parameters():
|
||||
p.requires_grad = False
|
||||
|
||||
if pretrain_mm_mlp_adapter:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
embed_tokens_weight = mm_projector_weights['model.embed_tokens.weight']
|
||||
assert num_new_tokens == 2
|
||||
if input_embeddings.shape == embed_tokens_weight.shape:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
|
||||
elif embed_tokens_weight.shape[0] == num_new_tokens:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight
|
||||
else:
|
||||
raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
|
||||
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
|
||||
AutoConfig.register("llava", LlavaConfig)
|
||||
AutoModelForCausalLM.register(LlavaConfig, LlavaLlamaForCausalLM)
|
||||
@@ -1,281 +0,0 @@
|
||||
# Copyright 2023 Haotian Liu
|
||||
#
|
||||
# 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 typing import List, Optional, Tuple, Union
|
||||
import warnings
|
||||
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
from torch.nn import CrossEntropyLoss
|
||||
|
||||
import math
|
||||
|
||||
from transformers import AutoConfig, AutoModelForCausalLM, \
|
||||
CLIPVisionModel, CLIPImageProcessor
|
||||
|
||||
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
|
||||
|
||||
from .mpt.modeling_mpt import MPTConfig, MPTForCausalLM, MPTModel
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
class LlavaMPTConfig(MPTConfig):
|
||||
model_type = "llava_mpt"
|
||||
|
||||
|
||||
class LlavaMPTModel(MPTModel):
|
||||
config_class = LlavaMPTConfig
|
||||
|
||||
def __init__(self, config: MPTConfig, mm_vision_tower=None, mm_hidden_size=None):
|
||||
super(LlavaMPTModel, self).__init__(config)
|
||||
|
||||
if hasattr(config, "mm_vision_tower"):
|
||||
# HACK: for FSDP
|
||||
self.vision_tower = [CLIPVisionModel.from_pretrained(config.mm_vision_tower)]
|
||||
# self.vision_tower = CLIPVisionModel.from_pretrained(config.mm_vision_tower)
|
||||
|
||||
if hasattr(config, "use_mm_proj"):
|
||||
self.mm_projector = nn.Linear(config.mm_hidden_size, config.d_model)
|
||||
|
||||
def initialize_vision_modules(self, vision_tower, mm_vision_select_layer,
|
||||
pretrain_mm_mlp_adapter=None, tune_mm_mlp_adapter=False):
|
||||
self.config.mm_vision_tower = vision_tower
|
||||
|
||||
image_processor = CLIPImageProcessor.from_pretrained(vision_tower)
|
||||
|
||||
if not hasattr(self, 'vision_tower'):
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower)
|
||||
else:
|
||||
vision_tower = self.vision_tower[0]
|
||||
vision_tower.requires_grad_(False)
|
||||
vision_tower = vision_tower.to(torch.float16)
|
||||
self.vision_tower = [vision_tower]
|
||||
|
||||
vision_config = vision_tower.config
|
||||
num_patches = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
self.config.use_mm_proj = True
|
||||
self.config.mm_hidden_size = vision_config.hidden_size
|
||||
self.config.mm_vision_select_layer = mm_vision_select_layer
|
||||
|
||||
if not hasattr(self, 'mm_projector'):
|
||||
self.mm_projector = nn.Linear(vision_config.hidden_size, self.config.d_model)
|
||||
|
||||
if pretrain_mm_mlp_adapter is not None:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
self.mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items() if 'mm_projector' in k})
|
||||
|
||||
return dict(
|
||||
image_processor=image_processor,
|
||||
image_token_len=num_patches,
|
||||
vision_config=vision_config
|
||||
)
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None, images=None):
|
||||
|
||||
# HACK: replace back original embeddings for LLaVA pretraining
|
||||
orig_embeds_params = getattr(self, 'orig_embeds_params', None)
|
||||
# if orig_embeds_params is not None:
|
||||
# orig_embeds_params = orig_embeds_params[0]
|
||||
# with torch.no_grad():
|
||||
# self.get_input_embeddings().weight.data[:-2] = orig_embeds_params[:-2].data
|
||||
|
||||
inputs_embeds = self.wte(input_ids)
|
||||
|
||||
vision_tower = getattr(self, 'vision_tower', None)
|
||||
if vision_tower is not None and (input_ids.shape[1] != 1 or self.training) and images is not None:
|
||||
# TODO: this is a modified multimodal LLM -- Haotian Liu
|
||||
vision_tower = vision_tower[0] # HACK: for FSDP
|
||||
with torch.no_grad():
|
||||
if type(images) is list:
|
||||
# variable length images
|
||||
image_features = []
|
||||
for image in images:
|
||||
image_forward_out = vision_tower(image.unsqueeze(0), output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_out.hidden_states[select_hidden_state_layer]
|
||||
image_feature = select_hidden_state[:, 1:]
|
||||
image_features.append(image_feature)
|
||||
else:
|
||||
image_forward_outs = vision_tower(images, output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_outs.hidden_states[select_hidden_state_layer]
|
||||
image_features = select_hidden_state[:, 1:]
|
||||
if type(images) is list:
|
||||
image_features = [self.mm_projector(image_feature)[0] for image_feature in image_features]
|
||||
else:
|
||||
image_features = self.mm_projector(image_features)
|
||||
dummy_image_features = torch.zeros(256, 1024, device=inputs_embeds.device, dtype=inputs_embeds.dtype)
|
||||
dummy_image_features = self.mm_projector(dummy_image_features)
|
||||
|
||||
new_input_embeds = []
|
||||
cur_image_idx = 0
|
||||
for cur_input_ids, cur_input_embeds in zip(input_ids, inputs_embeds):
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() == 0:
|
||||
# multimodal LLM, but the current sample is not multimodal
|
||||
cur_input_embeds = cur_input_embeds + (0. * dummy_image_features).sum()
|
||||
new_input_embeds.append(cur_input_embeds)
|
||||
continue
|
||||
if vision_tower.config.use_im_start_end:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_start_token).sum() != (cur_input_ids == vision_tower.config.im_end_token).sum():
|
||||
raise ValueError("The number of image start tokens and image end tokens should be the same.")
|
||||
image_start_tokens = torch.where(cur_input_ids == vision_tower.config.im_start_token)[0]
|
||||
for image_start_token_pos in image_start_tokens:
|
||||
cur_image_features = image_features[cur_image_idx].to(device=cur_input_embeds.device)
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if cur_input_ids[image_start_token_pos + num_patches + 1] != vision_tower.config.im_end_token:
|
||||
raise ValueError("The image end token should follow the image start token.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos].detach(), cur_input_embeds[image_start_token_pos:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:image_start_token_pos + num_patches + 2], cur_input_embeds[image_start_token_pos + num_patches + 2:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:]), dim=0)
|
||||
cur_image_idx += 1
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
else:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() != num_patches:
|
||||
raise ValueError("The number of image patch tokens should be the same as the number of image patches.")
|
||||
masked_indices = torch.where(cur_input_ids == vision_tower.config.im_patch_token)[0]
|
||||
mask_index_start = masked_indices[0]
|
||||
if (masked_indices != torch.arange(mask_index_start, mask_index_start+num_patches, device=masked_indices.device, dtype=masked_indices.dtype)).any():
|
||||
raise ValueError("The image patch tokens should be consecutive.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start].detach(), cur_image_features, cur_input_embeds[mask_index_start+num_patches:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start], cur_image_features, cur_input_embeds[mask_index_start+num_patches:]), dim=0)
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
inputs_embeds = torch.stack(new_input_embeds, dim=0)
|
||||
|
||||
return super(LlavaMPTModel, self).forward(input_ids=None, past_key_values=past_key_values, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id, return_dict=return_dict, output_attentions=output_attentions, output_hidden_states=output_hidden_states, use_cache=use_cache, tok_emb=inputs_embeds)
|
||||
|
||||
|
||||
class LlavaMPTForCausalLM(MPTForCausalLM):
|
||||
config_class = LlavaMPTConfig
|
||||
supports_gradient_checkpointing = True
|
||||
|
||||
def __init__(self, config):
|
||||
super(MPTForCausalLM, self).__init__(config)
|
||||
|
||||
if not config.tie_word_embeddings:
|
||||
raise ValueError('MPTForCausalLM only supports tied word embeddings')
|
||||
self.transformer = LlavaMPTModel(config)
|
||||
self.logit_scale = None
|
||||
if config.logit_scale is not None:
|
||||
logit_scale = config.logit_scale
|
||||
if isinstance(logit_scale, str):
|
||||
if logit_scale == 'inv_sqrt_d_model':
|
||||
logit_scale = 1 / math.sqrt(config.d_model)
|
||||
else:
|
||||
raise ValueError(f"logit_scale={logit_scale!r} is not recognized as an option; use numeric value or 'inv_sqrt_d_model'.")
|
||||
self.logit_scale = logit_scale
|
||||
|
||||
def get_model(self):
|
||||
return self.transformer
|
||||
|
||||
def _set_gradient_checkpointing(self, module, value=False):
|
||||
if isinstance(module, LlavaMPTModel):
|
||||
module.gradient_checkpointing = value
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, labels: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None, images=None):
|
||||
return_dict = return_dict if return_dict is not None else self.config.return_dict
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
outputs = self.transformer(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id, return_dict=return_dict, output_attentions=output_attentions, output_hidden_states=output_hidden_states, use_cache=use_cache, images=images)
|
||||
logits = F.linear(outputs.last_hidden_state, self.transformer.wte.weight)
|
||||
if self.logit_scale is not None:
|
||||
if self.logit_scale == 0:
|
||||
warnings.warn(f'Multiplying logits by self.logit_scale={self.logit_scale!r}. This will produce uniform (uninformative) outputs.')
|
||||
logits *= self.logit_scale
|
||||
loss = None
|
||||
if labels is not None:
|
||||
labels = torch.roll(labels, shifts=-1)
|
||||
labels[:, -1] = -100
|
||||
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), labels.to(logits.device).view(-1))
|
||||
return CausalLMOutputWithPast(loss=loss, logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states)
|
||||
|
||||
def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
|
||||
if inputs_embeds is not None:
|
||||
raise NotImplementedError('inputs_embeds is not implemented for MPT yet')
|
||||
attention_mask = kwargs['attention_mask'].bool()
|
||||
if attention_mask[:, -1].sum() != attention_mask.shape[0]:
|
||||
raise NotImplementedError('MPT does not support generation with right padding.')
|
||||
if self.transformer.attn_uses_sequence_id and self.training:
|
||||
sequence_id = torch.zeros_like(input_ids[:1])
|
||||
else:
|
||||
sequence_id = None
|
||||
if past_key_values is not None:
|
||||
input_ids = input_ids[:, -1].unsqueeze(-1)
|
||||
if self.transformer.prefix_lm:
|
||||
prefix_mask = torch.ones_like(attention_mask)
|
||||
if kwargs.get('use_cache') == False:
|
||||
raise NotImplementedError('MPT with prefix_lm=True does not support use_cache=False.')
|
||||
else:
|
||||
prefix_mask = None
|
||||
return {'input_ids': input_ids, 'attention_mask': attention_mask, 'prefix_mask': prefix_mask, 'sequence_id': sequence_id, 'past_key_values': past_key_values, 'use_cache': kwargs.get('use_cache', True), "images": kwargs.get("images", None)}
|
||||
|
||||
def initialize_vision_tokenizer(self, mm_use_im_start_end, tokenizer, device,
|
||||
tune_mm_mlp_adapter=False, pretrain_mm_mlp_adapter=None):
|
||||
vision_config = self.get_model().vision_tower[0].config
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
|
||||
if mm_use_im_start_end:
|
||||
num_new_tokens = tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
if num_new_tokens > 0:
|
||||
input_embeddings = self.get_input_embeddings().weight.data
|
||||
output_embeddings = self.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
|
||||
|
||||
if tune_mm_mlp_adapter:
|
||||
self.get_model().orig_embeds_params = [self.get_input_embeddings().weight.data.clone().to(device=device)]
|
||||
for p in self.get_input_embeddings().parameters():
|
||||
p.requires_grad = True
|
||||
for p in self.get_output_embeddings().parameters():
|
||||
p.requires_grad = False
|
||||
|
||||
if pretrain_mm_mlp_adapter:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
embed_tokens_weight = mm_projector_weights['transformer.wte.weight']
|
||||
assert num_new_tokens == 2
|
||||
if input_embeddings.shape == embed_tokens_weight.shape:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
|
||||
elif embed_tokens_weight.shape[0] == num_new_tokens:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight
|
||||
else:
|
||||
raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
|
||||
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
|
||||
AutoConfig.register("llava_mpt", LlavaMPTConfig)
|
||||
AutoModelForCausalLM.register(LlavaMPTConfig, LlavaMPTForCausalLM)
|
||||
@@ -1,52 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m llava.model.make_delta --base ~/model_weights/llama-7b --target ~/model_weights/llava-7b --delta ~/model_weights/llava-7b-delta --hub-repo-id liuhaotian/llava-7b-delta
|
||||
"""
|
||||
import argparse
|
||||
|
||||
import torch
|
||||
from tqdm import tqdm
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
from llava.model.utils import auto_upgrade
|
||||
|
||||
|
||||
def make_delta(base_model_path, target_model_path, delta_path, hub_repo_id):
|
||||
print("Loading base model")
|
||||
base = AutoModelForCausalLM.from_pretrained(
|
||||
base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
|
||||
print("Loading target model")
|
||||
auto_upgrade(target_model_path)
|
||||
target = AutoModelForCausalLM.from_pretrained(target_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
|
||||
print("Calculating delta")
|
||||
for name, param in tqdm(target.state_dict().items(), desc="Calculating delta"):
|
||||
if name not in base.state_dict():
|
||||
assert name in ['model.mm_projector.weight', 'model.mm_projector.bias'], f'{name} not in base model'
|
||||
continue
|
||||
if param.data.shape == base.state_dict()[name].shape:
|
||||
param.data -= base.state_dict()[name]
|
||||
else:
|
||||
assert name in ['model.embed_tokens.weight', 'lm_head.weight'], f'{name} dimension mismatch: {param.data.shape} vs {base.state_dict()[name].shape}'
|
||||
bparam = base.state_dict()[name]
|
||||
param.data[:bparam.shape[0], :bparam.shape[1]] -= bparam
|
||||
|
||||
print("Saving delta")
|
||||
if hub_repo_id:
|
||||
kwargs = {"push_to_hub": True, "repo_id": hub_repo_id}
|
||||
else:
|
||||
kwargs = {}
|
||||
target.save_pretrained(delta_path, **kwargs)
|
||||
target_tokenizer = AutoTokenizer.from_pretrained(target_model_path)
|
||||
target_tokenizer.save_pretrained(delta_path, **kwargs)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-model-path", type=str, required=True)
|
||||
parser.add_argument("--target-model-path", type=str, required=True)
|
||||
parser.add_argument("--delta-path", type=str, required=True)
|
||||
parser.add_argument("--hub-repo-id", type=str, default=None)
|
||||
args = parser.parse_args()
|
||||
|
||||
make_delta(args.base_model_path, args.target_model_path, args.delta_path, args.hub_repo_id)
|
||||
@@ -1,41 +0,0 @@
|
||||
from typing import Union
|
||||
from transformers import AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast
|
||||
Tokenizer = Union[PreTrainedTokenizer, PreTrainedTokenizerFast]
|
||||
NUM_SENTINEL_TOKENS: int = 100
|
||||
|
||||
def adapt_tokenizer_for_denoising(tokenizer: Tokenizer):
|
||||
"""Adds sentinel tokens and padding token (if missing).
|
||||
|
||||
Expands the tokenizer vocabulary to include sentinel tokens
|
||||
used in mixture-of-denoiser tasks as well as a padding token.
|
||||
|
||||
All added tokens are added as special tokens. No tokens are
|
||||
added if sentinel tokens and padding token already exist.
|
||||
"""
|
||||
sentinels_to_add = [f'<extra_id_{i}>' for i in range(NUM_SENTINEL_TOKENS)]
|
||||
tokenizer.add_tokens(sentinels_to_add, special_tokens=True)
|
||||
if tokenizer.pad_token is None:
|
||||
tokenizer.add_tokens('<pad>', special_tokens=True)
|
||||
tokenizer.pad_token = '<pad>'
|
||||
assert tokenizer.pad_token_id is not None
|
||||
sentinels = ''.join([f'<extra_id_{i}>' for i in range(NUM_SENTINEL_TOKENS)])
|
||||
_sentinel_token_ids = tokenizer(sentinels, add_special_tokens=False).input_ids
|
||||
tokenizer.sentinel_token_ids = _sentinel_token_ids
|
||||
|
||||
class AutoTokenizerForMOD(AutoTokenizer):
|
||||
"""AutoTokenizer + Adaptation for MOD.
|
||||
|
||||
A simple wrapper around AutoTokenizer to make instantiating
|
||||
an MOD-adapted tokenizer a bit easier.
|
||||
|
||||
MOD-adapted tokenizers have sentinel tokens (e.g., <extra_id_0>),
|
||||
a padding token, and a property to get the token ids of the
|
||||
sentinel tokens.
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def from_pretrained(cls, *args, **kwargs):
|
||||
"""See `AutoTokenizer.from_pretrained` docstring."""
|
||||
tokenizer = super().from_pretrained(*args, **kwargs)
|
||||
adapt_tokenizer_for_denoising(tokenizer)
|
||||
return tokenizer
|
||||
@@ -1,276 +0,0 @@
|
||||
"""Attention layers."""
|
||||
import math
|
||||
import warnings
|
||||
from typing import Optional
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
from einops import rearrange
|
||||
from torch import nn
|
||||
from .norm import LPLayerNorm
|
||||
|
||||
def _reset_is_causal(num_query_tokens: int, num_key_tokens: int, original_is_causal: bool):
|
||||
if original_is_causal and num_query_tokens != num_key_tokens:
|
||||
if num_query_tokens != 1:
|
||||
raise NotImplementedError('MPT does not support query and key with different number of tokens, unless number of query tokens is 1.')
|
||||
else:
|
||||
return False
|
||||
return original_is_causal
|
||||
|
||||
def scaled_multihead_dot_product_attention(query, key, value, n_heads, softmax_scale=None, attn_bias=None, key_padding_mask=None, is_causal=False, dropout_p=0.0, training=False, needs_weights=False, multiquery=False):
|
||||
q = rearrange(query, 'b s (h d) -> b h s d', h=n_heads)
|
||||
k = rearrange(key, 'b s (h d) -> b h d s', h=1 if multiquery else n_heads)
|
||||
v = rearrange(value, 'b s (h d) -> b h s d', h=1 if multiquery else n_heads)
|
||||
min_val = torch.finfo(q.dtype).min
|
||||
(b, _, s_q, d) = q.shape
|
||||
s_k = k.size(-1)
|
||||
if softmax_scale is None:
|
||||
softmax_scale = 1 / math.sqrt(d)
|
||||
attn_weight = q.matmul(k) * softmax_scale
|
||||
if attn_bias is not None:
|
||||
if attn_bias.size(-1) != 1 and attn_bias.size(-1) != s_k or (attn_bias.size(-2) != 1 and attn_bias.size(-2) != s_q):
|
||||
raise RuntimeError(f'attn_bias (shape: {attn_bias.shape}) is expected to broadcast to shape: {attn_weight.shape}.')
|
||||
attn_weight = attn_weight + attn_bias
|
||||
if key_padding_mask is not None:
|
||||
if attn_bias is not None:
|
||||
warnings.warn('Propogating key_padding_mask to the attention module ' + 'and applying it within the attention module can cause ' + 'unneccessary computation/memory usage. Consider integrating ' + 'into attn_bias once and passing that to each attention ' + 'module instead.')
|
||||
attn_weight = attn_weight.masked_fill(~key_padding_mask.view((b, 1, 1, s_k)), min_val)
|
||||
if is_causal:
|
||||
s = max(s_q, s_k)
|
||||
causal_mask = attn_weight.new_ones(s, s, dtype=torch.float16)
|
||||
causal_mask = causal_mask.tril()
|
||||
causal_mask = causal_mask.to(torch.bool)
|
||||
causal_mask = ~causal_mask
|
||||
causal_mask = causal_mask[-s_q:, -s_k:]
|
||||
attn_weight = attn_weight.masked_fill(causal_mask.view(1, 1, s_q, s_k), min_val)
|
||||
attn_weight = torch.softmax(attn_weight, dim=-1)
|
||||
if dropout_p:
|
||||
attn_weight = torch.nn.functional.dropout(attn_weight, p=dropout_p, training=training, inplace=True)
|
||||
out = attn_weight.matmul(v)
|
||||
out = rearrange(out, 'b h s d -> b s (h d)')
|
||||
if needs_weights:
|
||||
return (out, attn_weight)
|
||||
return (out, None)
|
||||
|
||||
def check_valid_inputs(*tensors, valid_dtypes=[torch.float16, torch.bfloat16]):
|
||||
for tensor in tensors:
|
||||
if tensor.dtype not in valid_dtypes:
|
||||
raise TypeError(f'tensor.dtype={tensor.dtype!r} must be in valid_dtypes={valid_dtypes!r}.')
|
||||
if not tensor.is_cuda:
|
||||
raise TypeError(f'Inputs must be cuda tensors (tensor.is_cuda={tensor.is_cuda!r}).')
|
||||
|
||||
def flash_attn_fn(query, key, value, n_heads, softmax_scale=None, attn_bias=None, key_padding_mask=None, is_causal=False, dropout_p=0.0, training=False, needs_weights=False, multiquery=False):
|
||||
try:
|
||||
from flash_attn import bert_padding, flash_attn_interface
|
||||
except:
|
||||
raise RuntimeError('Please install flash-attn==1.0.3.post0')
|
||||
check_valid_inputs(query, key, value)
|
||||
if attn_bias is not None:
|
||||
raise NotImplementedError(f'attn_bias not implemented for flash attn.')
|
||||
(batch_size, seqlen) = query.shape[:2]
|
||||
if key_padding_mask is None:
|
||||
key_padding_mask = torch.ones_like(key[:, :, 0], dtype=torch.bool)
|
||||
query_padding_mask = key_padding_mask[:, -query.size(1):]
|
||||
(query_unpad, indices_q, cu_seqlens_q, max_seqlen_q) = bert_padding.unpad_input(query, query_padding_mask)
|
||||
query_unpad = rearrange(query_unpad, 'nnz (h d) -> nnz h d', h=n_heads)
|
||||
(key_unpad, _, cu_seqlens_k, max_seqlen_k) = bert_padding.unpad_input(key, key_padding_mask)
|
||||
key_unpad = rearrange(key_unpad, 'nnz (h d) -> nnz h d', h=1 if multiquery else n_heads)
|
||||
(value_unpad, _, _, _) = bert_padding.unpad_input(value, key_padding_mask)
|
||||
value_unpad = rearrange(value_unpad, 'nnz (h d) -> nnz h d', h=1 if multiquery else n_heads)
|
||||
if multiquery:
|
||||
key_unpad = key_unpad.expand(key_unpad.size(0), n_heads, key_unpad.size(-1))
|
||||
value_unpad = value_unpad.expand(value_unpad.size(0), n_heads, value_unpad.size(-1))
|
||||
dropout_p = dropout_p if training else 0.0
|
||||
reset_is_causal = _reset_is_causal(query.size(1), key.size(1), is_causal)
|
||||
output_unpad = flash_attn_interface.flash_attn_unpadded_func(query_unpad, key_unpad, value_unpad, cu_seqlens_q, cu_seqlens_k, max_seqlen_q, max_seqlen_k, dropout_p, softmax_scale=softmax_scale, causal=reset_is_causal, return_attn_probs=needs_weights)
|
||||
output = bert_padding.pad_input(rearrange(output_unpad, 'nnz h d -> nnz (h d)'), indices_q, batch_size, seqlen)
|
||||
return (output, None)
|
||||
|
||||
def triton_flash_attn_fn(query, key, value, n_heads, softmax_scale=None, attn_bias=None, key_padding_mask=None, is_causal=False, dropout_p=0.0, training=False, needs_weights=False, multiquery=False):
|
||||
try:
|
||||
from flash_attn import flash_attn_triton
|
||||
except:
|
||||
raise RuntimeError('Please install flash-attn==1.0.3.post0 and triton==2.0.0.dev20221202')
|
||||
check_valid_inputs(query, key, value)
|
||||
if dropout_p:
|
||||
raise NotImplementedError(f'Dropout not implemented for attn_impl: triton.')
|
||||
if needs_weights:
|
||||
raise NotImplementedError(f'attn_impl: triton cannot return attn weights.')
|
||||
if key_padding_mask is not None:
|
||||
warnings.warn('Propagating key_padding_mask to the attention module ' + 'and applying it within the attention module can cause ' + 'unnecessary computation/memory usage. Consider integrating ' + 'into attn_bias once and passing that to each attention ' + 'module instead.')
|
||||
(b_size, s_k) = key_padding_mask.shape[:2]
|
||||
if attn_bias is None:
|
||||
attn_bias = query.new_zeros(b_size, 1, 1, s_k)
|
||||
attn_bias = attn_bias.masked_fill(~key_padding_mask.view((b_size, 1, 1, s_k)), torch.finfo(query.dtype).min)
|
||||
query = rearrange(query, 'b s (h d) -> b s h d', h=n_heads)
|
||||
key = rearrange(key, 'b s (h d) -> b s h d', h=1 if multiquery else n_heads)
|
||||
value = rearrange(value, 'b s (h d) -> b s h d', h=1 if multiquery else n_heads)
|
||||
if multiquery:
|
||||
key = key.expand(*key.shape[:2], n_heads, key.size(-1))
|
||||
value = value.expand(*value.shape[:2], n_heads, value.size(-1))
|
||||
reset_is_causal = _reset_is_causal(query.size(1), key.size(1), is_causal)
|
||||
attn_output = flash_attn_triton.flash_attn_func(query, key, value, attn_bias, reset_is_causal, softmax_scale)
|
||||
output = attn_output.view(*attn_output.shape[:2], -1)
|
||||
return (output, None)
|
||||
|
||||
class MultiheadAttention(nn.Module):
|
||||
"""Multi-head self attention.
|
||||
|
||||
Using torch or triton attention implemetation enables user to also use
|
||||
additive bias.
|
||||
"""
|
||||
|
||||
def __init__(self, d_model: int, n_heads: int, attn_impl: str='triton', clip_qkv: Optional[float]=None, qk_ln: bool=False, softmax_scale: Optional[float]=None, attn_pdrop: float=0.0, low_precision_layernorm: bool=False, device: Optional[str]=None):
|
||||
super().__init__()
|
||||
self.attn_impl = attn_impl
|
||||
self.clip_qkv = clip_qkv
|
||||
self.qk_ln = qk_ln
|
||||
self.d_model = d_model
|
||||
self.n_heads = n_heads
|
||||
self.softmax_scale = softmax_scale
|
||||
if self.softmax_scale is None:
|
||||
self.softmax_scale = 1 / math.sqrt(self.d_model / self.n_heads)
|
||||
self.attn_dropout_p = attn_pdrop
|
||||
self.Wqkv = nn.Linear(self.d_model, 3 * self.d_model, device=device)
|
||||
fuse_splits = (d_model, 2 * d_model)
|
||||
self.Wqkv._fused = (0, fuse_splits)
|
||||
if self.qk_ln:
|
||||
layernorm_class = LPLayerNorm if low_precision_layernorm else nn.LayerNorm
|
||||
self.q_ln = layernorm_class(self.d_model, device=device)
|
||||
self.k_ln = layernorm_class(self.d_model, device=device)
|
||||
if self.attn_impl == 'flash':
|
||||
self.attn_fn = flash_attn_fn
|
||||
elif self.attn_impl == 'triton':
|
||||
self.attn_fn = triton_flash_attn_fn
|
||||
warnings.warn('While `attn_impl: triton` can be faster than `attn_impl: flash` ' + 'it uses more memory. When training larger models this can trigger ' + 'alloc retries which hurts performance. If encountered, we recommend ' + 'using `attn_impl: flash` if your model does not use `alibi` or `prefix_lm`.')
|
||||
elif self.attn_impl == 'torch':
|
||||
self.attn_fn = scaled_multihead_dot_product_attention
|
||||
if torch.cuda.is_available():
|
||||
warnings.warn('Using `attn_impl: torch`. If your model does not use `alibi` or ' + '`prefix_lm` we recommend using `attn_impl: flash` otherwise ' + 'we recommend using `attn_impl: triton`.')
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
self.out_proj = nn.Linear(self.d_model, self.d_model, device=device)
|
||||
self.out_proj._is_residual = True
|
||||
|
||||
def forward(self, x, past_key_value=None, attn_bias=None, attention_mask=None, is_causal=True, needs_weights=False):
|
||||
qkv = self.Wqkv(x)
|
||||
if self.clip_qkv:
|
||||
qkv.clamp_(min=-self.clip_qkv, max=self.clip_qkv)
|
||||
(query, key, value) = qkv.chunk(3, dim=2)
|
||||
key_padding_mask = attention_mask
|
||||
if self.qk_ln:
|
||||
dtype = query.dtype
|
||||
query = self.q_ln(query).to(dtype)
|
||||
key = self.k_ln(key).to(dtype)
|
||||
if past_key_value is not None:
|
||||
if len(past_key_value) != 0:
|
||||
key = torch.cat([past_key_value[0], key], dim=1)
|
||||
value = torch.cat([past_key_value[1], value], dim=1)
|
||||
past_key_value = (key, value)
|
||||
if attn_bias is not None:
|
||||
attn_bias = attn_bias[:, :, -query.size(1):, -key.size(1):]
|
||||
(context, attn_weights) = self.attn_fn(query, key, value, self.n_heads, softmax_scale=self.softmax_scale, attn_bias=attn_bias, key_padding_mask=key_padding_mask, is_causal=is_causal, dropout_p=self.attn_dropout_p, training=self.training, needs_weights=needs_weights)
|
||||
return (self.out_proj(context), attn_weights, past_key_value)
|
||||
|
||||
class MultiQueryAttention(nn.Module):
|
||||
"""Multi-Query self attention.
|
||||
|
||||
Using torch or triton attention implemetation enables user to also use
|
||||
additive bias.
|
||||
"""
|
||||
|
||||
def __init__(self, d_model: int, n_heads: int, attn_impl: str='triton', clip_qkv: Optional[float]=None, qk_ln: bool=False, softmax_scale: Optional[float]=None, attn_pdrop: float=0.0, low_precision_layernorm: bool=False, device: Optional[str]=None):
|
||||
super().__init__()
|
||||
self.attn_impl = attn_impl
|
||||
self.clip_qkv = clip_qkv
|
||||
self.qk_ln = qk_ln
|
||||
self.d_model = d_model
|
||||
self.n_heads = n_heads
|
||||
self.head_dim = d_model // n_heads
|
||||
self.softmax_scale = softmax_scale
|
||||
if self.softmax_scale is None:
|
||||
self.softmax_scale = 1 / math.sqrt(self.head_dim)
|
||||
self.attn_dropout_p = attn_pdrop
|
||||
self.Wqkv = nn.Linear(d_model, d_model + 2 * self.head_dim, device=device)
|
||||
fuse_splits = (d_model, d_model + self.head_dim)
|
||||
self.Wqkv._fused = (0, fuse_splits)
|
||||
if self.qk_ln:
|
||||
layernorm_class = LPLayerNorm if low_precision_layernorm else nn.LayerNorm
|
||||
self.q_ln = layernorm_class(d_model, device=device)
|
||||
self.k_ln = layernorm_class(self.head_dim, device=device)
|
||||
if self.attn_impl == 'flash':
|
||||
self.attn_fn = flash_attn_fn
|
||||
elif self.attn_impl == 'triton':
|
||||
self.attn_fn = triton_flash_attn_fn
|
||||
warnings.warn('While `attn_impl: triton` can be faster than `attn_impl: flash` ' + 'it uses more memory. When training larger models this can trigger ' + 'alloc retries which hurts performance. If encountered, we recommend ' + 'using `attn_impl: flash` if your model does not use `alibi` or `prefix_lm`.')
|
||||
elif self.attn_impl == 'torch':
|
||||
self.attn_fn = scaled_multihead_dot_product_attention
|
||||
if torch.cuda.is_available():
|
||||
warnings.warn('Using `attn_impl: torch`. If your model does not use `alibi` or ' + '`prefix_lm` we recommend using `attn_impl: flash` otherwise ' + 'we recommend using `attn_impl: triton`.')
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
self.out_proj = nn.Linear(self.d_model, self.d_model, device=device)
|
||||
self.out_proj._is_residual = True
|
||||
|
||||
def forward(self, x, past_key_value=None, attn_bias=None, attention_mask=None, is_causal=True, needs_weights=False):
|
||||
qkv = self.Wqkv(x)
|
||||
if self.clip_qkv:
|
||||
qkv.clamp_(min=-self.clip_qkv, max=self.clip_qkv)
|
||||
(query, key, value) = qkv.split([self.d_model, self.head_dim, self.head_dim], dim=2)
|
||||
key_padding_mask = attention_mask
|
||||
if self.qk_ln:
|
||||
dtype = query.dtype
|
||||
query = self.q_ln(query).to(dtype)
|
||||
key = self.k_ln(key).to(dtype)
|
||||
if past_key_value is not None:
|
||||
if len(past_key_value) != 0:
|
||||
key = torch.cat([past_key_value[0], key], dim=1)
|
||||
value = torch.cat([past_key_value[1], value], dim=1)
|
||||
past_key_value = (key, value)
|
||||
if attn_bias is not None:
|
||||
attn_bias = attn_bias[:, :, -query.size(1):, -key.size(1):]
|
||||
(context, attn_weights) = self.attn_fn(query, key, value, self.n_heads, softmax_scale=self.softmax_scale, attn_bias=attn_bias, key_padding_mask=key_padding_mask, is_causal=is_causal, dropout_p=self.attn_dropout_p, training=self.training, needs_weights=needs_weights, multiquery=True)
|
||||
return (self.out_proj(context), attn_weights, past_key_value)
|
||||
|
||||
def attn_bias_shape(attn_impl, n_heads, seq_len, alibi, prefix_lm, causal, use_sequence_id):
|
||||
if attn_impl == 'flash':
|
||||
return None
|
||||
elif attn_impl in ['torch', 'triton']:
|
||||
if alibi:
|
||||
if (prefix_lm or not causal) or use_sequence_id:
|
||||
return (1, n_heads, seq_len, seq_len)
|
||||
return (1, n_heads, 1, seq_len)
|
||||
elif prefix_lm or use_sequence_id:
|
||||
return (1, 1, seq_len, seq_len)
|
||||
return None
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
|
||||
def build_attn_bias(attn_impl, attn_bias, n_heads, seq_len, causal=False, alibi=False, alibi_bias_max=8):
|
||||
if attn_impl == 'flash':
|
||||
return None
|
||||
elif attn_impl in ['torch', 'triton']:
|
||||
if alibi:
|
||||
(device, dtype) = (attn_bias.device, attn_bias.dtype)
|
||||
attn_bias = attn_bias.add(build_alibi_bias(n_heads, seq_len, full=not causal, alibi_bias_max=alibi_bias_max, device=device, dtype=dtype))
|
||||
return attn_bias
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
|
||||
def gen_slopes(n_heads, alibi_bias_max=8, device=None):
|
||||
_n_heads = 2 ** math.ceil(math.log2(n_heads))
|
||||
m = torch.arange(1, _n_heads + 1, dtype=torch.float32, device=device)
|
||||
m = m.mul(alibi_bias_max / _n_heads)
|
||||
slopes = 1.0 / torch.pow(2, m)
|
||||
if _n_heads != n_heads:
|
||||
slopes = torch.concat([slopes[1::2], slopes[::2]])[:n_heads]
|
||||
return slopes.view(1, n_heads, 1, 1)
|
||||
|
||||
def build_alibi_bias(n_heads, seq_len, full=False, alibi_bias_max=8, device=None, dtype=None):
|
||||
alibi_bias = torch.arange(1 - seq_len, 1, dtype=torch.int32, device=device).view(1, 1, 1, seq_len)
|
||||
if full:
|
||||
alibi_bias = alibi_bias - torch.arange(1 - seq_len, 1, dtype=torch.int32, device=device).view(1, 1, seq_len, 1)
|
||||
alibi_bias = alibi_bias.abs().mul(-1)
|
||||
slopes = gen_slopes(n_heads, alibi_bias_max, device=device)
|
||||
alibi_bias = alibi_bias * slopes
|
||||
return alibi_bias.to(dtype=dtype)
|
||||
ATTN_CLASS_REGISTRY = {'multihead_attention': MultiheadAttention, 'multiquery_attention': MultiQueryAttention}
|
||||
@@ -1,41 +0,0 @@
|
||||
"""GPT Blocks used for the GPT Model."""
|
||||
from typing import Dict, Optional, Tuple
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
from .attention import ATTN_CLASS_REGISTRY
|
||||
from .norm import NORM_CLASS_REGISTRY
|
||||
|
||||
class MPTMLP(nn.Module):
|
||||
|
||||
def __init__(self, d_model: int, expansion_ratio: int, device: Optional[str]=None):
|
||||
super().__init__()
|
||||
self.up_proj = nn.Linear(d_model, expansion_ratio * d_model, device=device)
|
||||
self.act = nn.GELU(approximate='none')
|
||||
self.down_proj = nn.Linear(expansion_ratio * d_model, d_model, device=device)
|
||||
self.down_proj._is_residual = True
|
||||
|
||||
def forward(self, x):
|
||||
return self.down_proj(self.act(self.up_proj(x)))
|
||||
|
||||
class MPTBlock(nn.Module):
|
||||
|
||||
def __init__(self, d_model: int, n_heads: int, expansion_ratio: int, attn_config: Dict={'attn_type': 'multihead_attention', 'attn_pdrop': 0.0, 'attn_impl': 'triton', 'qk_ln': False, 'clip_qkv': None, 'softmax_scale': None, 'prefix_lm': False, 'attn_uses_sequence_id': False, 'alibi': False, 'alibi_bias_max': 8}, resid_pdrop: float=0.0, norm_type: str='low_precision_layernorm', device: Optional[str]=None, **kwargs):
|
||||
del kwargs
|
||||
super().__init__()
|
||||
norm_class = NORM_CLASS_REGISTRY[norm_type.lower()]
|
||||
attn_class = ATTN_CLASS_REGISTRY[attn_config['attn_type']]
|
||||
self.norm_1 = norm_class(d_model, device=device)
|
||||
self.attn = attn_class(attn_impl=attn_config['attn_impl'], clip_qkv=attn_config['clip_qkv'], qk_ln=attn_config['qk_ln'], softmax_scale=attn_config['softmax_scale'], attn_pdrop=attn_config['attn_pdrop'], d_model=d_model, n_heads=n_heads, device=device)
|
||||
self.norm_2 = norm_class(d_model, device=device)
|
||||
self.ffn = MPTMLP(d_model=d_model, expansion_ratio=expansion_ratio, device=device)
|
||||
self.resid_attn_dropout = nn.Dropout(resid_pdrop)
|
||||
self.resid_ffn_dropout = nn.Dropout(resid_pdrop)
|
||||
|
||||
def forward(self, x: torch.Tensor, past_key_value: Optional[Tuple[torch.Tensor]]=None, attn_bias: Optional[torch.Tensor]=None, attention_mask: Optional[torch.ByteTensor]=None, is_causal: bool=True) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor]]]:
|
||||
a = self.norm_1(x)
|
||||
(b, _, past_key_value) = self.attn(a, past_key_value=past_key_value, attn_bias=attn_bias, attention_mask=attention_mask, is_causal=is_causal)
|
||||
x = x + self.resid_attn_dropout(b)
|
||||
m = self.norm_2(x)
|
||||
n = self.ffn(m)
|
||||
x = x + self.resid_ffn_dropout(n)
|
||||
return (x, past_key_value)
|
||||
@@ -1,118 +0,0 @@
|
||||
"""A HuggingFace-style model configuration."""
|
||||
from typing import Dict, Optional, Union
|
||||
from transformers import PretrainedConfig
|
||||
attn_config_defaults: Dict = {'attn_type': 'multihead_attention', 'attn_pdrop': 0.0, 'attn_impl': 'triton', 'qk_ln': False, 'clip_qkv': None, 'softmax_scale': None, 'prefix_lm': False, 'attn_uses_sequence_id': False, 'alibi': False, 'alibi_bias_max': 8}
|
||||
init_config_defaults: Dict = {'name': 'kaiming_normal_', 'fan_mode': 'fan_in', 'init_nonlinearity': 'relu'}
|
||||
|
||||
class MPTConfig(PretrainedConfig):
|
||||
model_type = 'mpt'
|
||||
|
||||
def __init__(self, d_model: int=2048, n_heads: int=16, n_layers: int=24, expansion_ratio: int=4, max_seq_len: int=2048, vocab_size: int=50368, resid_pdrop: float=0.0, emb_pdrop: float=0.0, learned_pos_emb: bool=True, attn_config: Dict=attn_config_defaults, init_device: str='cpu', logit_scale: Optional[Union[float, str]]=None, no_bias: bool=False, verbose: int=0, embedding_fraction: float=1.0, norm_type: str='low_precision_layernorm', use_cache: bool=False, init_config: Dict=init_config_defaults, **kwargs):
|
||||
"""The MPT configuration class.
|
||||
|
||||
Args:
|
||||
d_model (int): The size of the embedding dimension of the model.
|
||||
n_heads (int): The number of attention heads.
|
||||
n_layers (int): The number of layers in the model.
|
||||
expansion_ratio (int): The ratio of the up/down scale in the MLP.
|
||||
max_seq_len (int): The maximum sequence length of the model.
|
||||
vocab_size (int): The size of the vocabulary.
|
||||
resid_pdrop (float): The dropout probability applied to the attention output before combining with residual.
|
||||
emb_pdrop (float): The dropout probability for the embedding layer.
|
||||
learned_pos_emb (bool): Whether to use learned positional embeddings
|
||||
attn_config (Dict): A dictionary used to configure the model's attention module:
|
||||
attn_type (str): type of attention to use. Options: multihead_attention, multiquery_attention
|
||||
attn_pdrop (float): The dropout probability for the attention layers.
|
||||
attn_impl (str): The attention implementation to use. One of 'torch', 'flash', or 'triton'.
|
||||
qk_ln (bool): Whether to apply layer normalization to the queries and keys in the attention layer.
|
||||
clip_qkv (Optional[float]): If not None, clip the queries, keys, and values in the attention layer to
|
||||
this value.
|
||||
softmax_scale (Optional[float]): If not None, scale the softmax in the attention layer by this value. If None,
|
||||
use the default scale of ``1/sqrt(d_keys)``.
|
||||
prefix_lm (Optional[bool]): Whether the model should operate as a Prefix LM. This requires passing an
|
||||
extra `prefix_mask` argument which indicates which tokens belong to the prefix. Tokens in the prefix
|
||||
can attend to one another bi-directionally. Tokens outside the prefix use causal attention.
|
||||
attn_uses_sequence_id (Optional[bool]): Whether to restrict attention to tokens that have the same sequence_id.
|
||||
When the model is in `train` mode, this requires passing an extra `sequence_id` argument which indicates
|
||||
which sub-sequence each token belongs to.
|
||||
Defaults to ``False`` meaning any provided `sequence_id` will be ignored.
|
||||
alibi (bool): Whether to use the alibi bias instead of position embeddings.
|
||||
alibi_bias_max (int): The maximum value of the alibi bias.
|
||||
init_device (str): The device to use for parameter initialization.
|
||||
logit_scale (Optional[Union[float, str]]): If not None, scale the logits by this value.
|
||||
no_bias (bool): Whether to use bias in all layers.
|
||||
verbose (int): The verbosity level. 0 is silent.
|
||||
embedding_fraction (float): The fraction to scale the gradients of the embedding layer by.
|
||||
norm_type (str): choose type of norm to use
|
||||
multiquery_attention (bool): Whether to use multiquery attention implementation.
|
||||
use_cache (bool): Whether or not the model should return the last key/values attentions
|
||||
init_config (Dict): A dictionary used to configure the model initialization:
|
||||
init_config.name: The parameter initialization scheme to use. Options: 'default_', 'baseline_',
|
||||
'kaiming_uniform_', 'kaiming_normal_', 'neox_init_', 'small_init_', 'xavier_uniform_', or
|
||||
'xavier_normal_'. These mimic the parameter initialization methods in PyTorch.
|
||||
init_div_is_residual (Union[int, float, str, bool]): Value to divide initial weights by if ``module._is_residual`` is True.
|
||||
emb_init_std (Optional[float]): The standard deviation of the normal distribution used to initialize the embedding layer.
|
||||
emb_init_uniform_lim (Optional[Union[Tuple[float, float], float]]): The lower and upper limits of the uniform distribution
|
||||
used to initialize the embedding layer. Mutually exclusive with ``emb_init_std``.
|
||||
init_std (float): The standard deviation of the normal distribution used to initialize the model,
|
||||
if using the baseline_ parameter initialization scheme.
|
||||
init_gain (float): The gain to use for parameter initialization with kaiming or xavier initialization schemes.
|
||||
fan_mode (str): The fan mode to use for parameter initialization with kaiming initialization schemes.
|
||||
init_nonlinearity (str): The nonlinearity to use for parameter initialization with kaiming initialization schemes.
|
||||
---
|
||||
See llmfoundry.models.utils.param_init_fns.py for info on other param init config options
|
||||
"""
|
||||
self.d_model = d_model
|
||||
self.n_heads = n_heads
|
||||
self.n_layers = n_layers
|
||||
self.expansion_ratio = expansion_ratio
|
||||
self.max_seq_len = max_seq_len
|
||||
self.vocab_size = vocab_size
|
||||
self.resid_pdrop = resid_pdrop
|
||||
self.emb_pdrop = emb_pdrop
|
||||
self.learned_pos_emb = learned_pos_emb
|
||||
self.attn_config = attn_config
|
||||
self.init_device = init_device
|
||||
self.logit_scale = logit_scale
|
||||
self.no_bias = no_bias
|
||||
self.verbose = verbose
|
||||
self.embedding_fraction = embedding_fraction
|
||||
self.norm_type = norm_type
|
||||
self.use_cache = use_cache
|
||||
self.init_config = init_config
|
||||
if 'name' in kwargs:
|
||||
del kwargs['name']
|
||||
if 'loss_fn' in kwargs:
|
||||
del kwargs['loss_fn']
|
||||
super().__init__(**kwargs)
|
||||
self._validate_config()
|
||||
|
||||
def _set_config_defaults(self, config, config_defaults):
|
||||
for (k, v) in config_defaults.items():
|
||||
if k not in config:
|
||||
config[k] = v
|
||||
return config
|
||||
|
||||
def _validate_config(self):
|
||||
self.attn_config = self._set_config_defaults(self.attn_config, attn_config_defaults)
|
||||
self.init_config = self._set_config_defaults(self.init_config, init_config_defaults)
|
||||
if self.d_model % self.n_heads != 0:
|
||||
raise ValueError('d_model must be divisible by n_heads')
|
||||
if any((prob < 0 or prob > 1 for prob in [self.attn_config['attn_pdrop'], self.resid_pdrop, self.emb_pdrop])):
|
||||
raise ValueError("self.attn_config['attn_pdrop'], resid_pdrop, emb_pdrop are probabilities and must be between 0 and 1")
|
||||
if self.attn_config['attn_impl'] not in ['torch', 'flash', 'triton']:
|
||||
raise ValueError(f"Unknown attn_impl={self.attn_config['attn_impl']}")
|
||||
if self.attn_config['prefix_lm'] and self.attn_config['attn_impl'] not in ['torch', 'triton']:
|
||||
raise NotImplementedError('prefix_lm only implemented with torch and triton attention.')
|
||||
if self.attn_config['alibi'] and self.attn_config['attn_impl'] not in ['torch', 'triton']:
|
||||
raise NotImplementedError('alibi only implemented with torch and triton attention.')
|
||||
if self.attn_config['attn_uses_sequence_id'] and self.attn_config['attn_impl'] not in ['torch', 'triton']:
|
||||
raise NotImplementedError('attn_uses_sequence_id only implemented with torch and triton attention.')
|
||||
if self.embedding_fraction > 1 or self.embedding_fraction <= 0:
|
||||
raise ValueError('model.embedding_fraction must be between 0 (exclusive) and 1 (inclusive)!')
|
||||
if isinstance(self.logit_scale, str) and self.logit_scale != 'inv_sqrt_d_model':
|
||||
raise ValueError(f"self.logit_scale={self.logit_scale!r} is not recognized as an option; use numeric value or 'inv_sqrt_d_model'.")
|
||||
if self.init_config.get('name', None) is None:
|
||||
raise ValueError(f"self.init_config={self.init_config!r} 'name' needs to be set.")
|
||||
if not self.learned_pos_emb and (not self.attn_config['alibi']):
|
||||
raise ValueError(f'Positional information must be provided to the model using either learned_pos_emb or alibi.')
|
||||
@@ -1,415 +0,0 @@
|
||||
"""Converts Huggingface Causal LM to Prefix LM.
|
||||
|
||||
Conversion does lightweight surgery on a HuggingFace
|
||||
Causal LM to convert it to a Prefix LM.
|
||||
|
||||
Prefix LMs accepts a `bidirectional_mask` input in `forward`
|
||||
and treat the input prompt as the prefix in `generate`.
|
||||
"""
|
||||
import math
|
||||
import warnings
|
||||
from types import MethodType
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
import torch
|
||||
from transformers.models.bloom.modeling_bloom import BaseModelOutputWithPastAndCrossAttentions, BloomForCausalLM, BloomModel, CausalLMOutputWithCrossAttentions, CrossEntropyLoss
|
||||
from transformers.models.bloom.modeling_bloom import _expand_mask as _expand_mask_bloom
|
||||
from transformers.models.bloom.modeling_bloom import _make_causal_mask as _make_causal_mask_bloom
|
||||
from transformers.models.bloom.modeling_bloom import logging
|
||||
from transformers.models.gpt2.modeling_gpt2 import GPT2LMHeadModel
|
||||
from transformers.models.gpt_neo.modeling_gpt_neo import GPTNeoForCausalLM
|
||||
from transformers.models.gpt_neox.modeling_gpt_neox import GPTNeoXForCausalLM
|
||||
from transformers.models.gptj.modeling_gptj import GPTJForCausalLM
|
||||
from transformers.models.opt.modeling_opt import OPTForCausalLM
|
||||
from transformers.models.opt.modeling_opt import _expand_mask as _expand_mask_opt
|
||||
from transformers.models.opt.modeling_opt import _make_causal_mask as _make_causal_mask_opt
|
||||
logger = logging.get_logger(__name__)
|
||||
_SUPPORTED_GPT_MODELS = (GPT2LMHeadModel, GPTJForCausalLM, GPTNeoForCausalLM, GPTNeoXForCausalLM)
|
||||
CAUSAL_GPT_TYPES = Union[GPT2LMHeadModel, GPTJForCausalLM, GPTNeoForCausalLM, GPTNeoXForCausalLM]
|
||||
|
||||
def _convert_gpt_causal_lm_to_prefix_lm(model: CAUSAL_GPT_TYPES) -> CAUSAL_GPT_TYPES:
|
||||
"""Converts a GPT-style Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `GPT2LMHeadModel`
|
||||
- `GPTNeoForCausalLM`
|
||||
- `GPTNeoXForCausalLM`
|
||||
- `GPTJForCausalLM`
|
||||
|
||||
See `convert_hf_causal_lm_to_prefix_lm` for more details.
|
||||
"""
|
||||
if hasattr(model, '_prefix_lm_converted'):
|
||||
return model
|
||||
assert isinstance(model, _SUPPORTED_GPT_MODELS)
|
||||
assert model.config.add_cross_attention == False, 'Only supports GPT-style decoder-only models'
|
||||
|
||||
def _get_attn_modules(model: CAUSAL_GPT_TYPES) -> List[torch.nn.Module]:
|
||||
"""Helper that gets a list of the model's attention modules.
|
||||
|
||||
Each module has a `bias` buffer used for causal masking. The Prefix LM
|
||||
conversion adds logic to dynamically manipulate these biases to support
|
||||
Prefix LM attention masking.
|
||||
"""
|
||||
attn_modules = []
|
||||
if isinstance(model, GPTNeoXForCausalLM):
|
||||
blocks = model.gpt_neox.layers
|
||||
else:
|
||||
blocks = model.transformer.h
|
||||
for block in blocks:
|
||||
if isinstance(model, GPTNeoForCausalLM):
|
||||
if block.attn.attention_type != 'global':
|
||||
continue
|
||||
attn_module = block.attn.attention
|
||||
elif isinstance(model, GPTNeoXForCausalLM):
|
||||
attn_module = block.attention
|
||||
else:
|
||||
attn_module = block.attn
|
||||
attn_modules.append(attn_module)
|
||||
return attn_modules
|
||||
setattr(model, '_original_forward', getattr(model, 'forward'))
|
||||
setattr(model, '_original_generate', getattr(model, 'generate'))
|
||||
|
||||
def forward(self: CAUSAL_GPT_TYPES, input_ids: Optional[torch.LongTensor]=None, past_key_values: Optional[Tuple[Tuple[torch.Tensor]]]=None, attention_mask: Optional[torch.FloatTensor]=None, bidirectional_mask: Optional[torch.Tensor]=None, token_type_ids: Optional[torch.LongTensor]=None, position_ids: Optional[torch.LongTensor]=None, head_mask: Optional[torch.FloatTensor]=None, inputs_embeds: Optional[torch.FloatTensor]=None, labels: Optional[torch.LongTensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None):
|
||||
"""Wraps original forward to enable PrefixLM attention."""
|
||||
|
||||
def call_og_forward():
|
||||
if isinstance(self, GPTNeoXForCausalLM):
|
||||
return self._original_forward(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, head_mask=head_mask, inputs_embeds=inputs_embeds, labels=labels, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
else:
|
||||
return self._original_forward(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, labels=labels, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
if bidirectional_mask is None:
|
||||
return call_og_forward()
|
||||
assert isinstance(bidirectional_mask, torch.Tensor)
|
||||
attn_modules = _get_attn_modules(model)
|
||||
(b, s) = bidirectional_mask.shape
|
||||
max_length = attn_modules[0].bias.shape[-1]
|
||||
if s > max_length:
|
||||
raise ValueError(f'bidirectional_mask sequence length (={s}) exceeds the ' + f'max length allowed by the model ({max_length}).')
|
||||
assert s <= max_length
|
||||
if s < max_length:
|
||||
pad = torch.zeros((int(b), int(max_length - s)), dtype=bidirectional_mask.dtype, device=bidirectional_mask.device)
|
||||
bidirectional_mask = torch.cat([bidirectional_mask, pad], dim=1)
|
||||
bidirectional = bidirectional_mask.unsqueeze(1).unsqueeze(1)
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data = torch.logical_or(attn_module.bias.data, bidirectional)
|
||||
output = call_og_forward()
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data = torch.tril(attn_module.bias.data[0, 0])[None, None]
|
||||
return output
|
||||
|
||||
def generate(self: CAUSAL_GPT_TYPES, *args: tuple, **kwargs: Dict[str, Any]):
|
||||
"""Wraps original generate to enable PrefixLM attention."""
|
||||
attn_modules = _get_attn_modules(model)
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data[:] = 1
|
||||
output = self._original_generate(*args, **kwargs)
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data = torch.tril(attn_module.bias.data[0, 0])[None, None]
|
||||
return output
|
||||
setattr(model, 'forward', MethodType(forward, model))
|
||||
setattr(model, 'generate', MethodType(generate, model))
|
||||
setattr(model, '_prefix_lm_converted', True)
|
||||
return model
|
||||
|
||||
def _convert_bloom_causal_lm_to_prefix_lm(model: BloomForCausalLM) -> BloomForCausalLM:
|
||||
"""Converts a BLOOM Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `BloomForCausalLM`
|
||||
|
||||
See `convert_hf_causal_lm_to_prefix_lm` for more details.
|
||||
"""
|
||||
if hasattr(model, '_prefix_lm_converted'):
|
||||
return model
|
||||
assert isinstance(model, BloomForCausalLM)
|
||||
assert model.config.add_cross_attention == False, 'Only supports BLOOM decoder-only models'
|
||||
|
||||
def _prepare_attn_mask(self: BloomModel, attention_mask: torch.Tensor, bidirectional_mask: Optional[torch.Tensor], input_shape: Tuple[int, int], past_key_values_length: int) -> torch.BoolTensor:
|
||||
combined_attention_mask = None
|
||||
device = attention_mask.device
|
||||
(_, src_length) = input_shape
|
||||
if src_length > 1:
|
||||
combined_attention_mask = _make_causal_mask_bloom(input_shape, device=device, past_key_values_length=past_key_values_length)
|
||||
if bidirectional_mask is not None:
|
||||
assert attention_mask.shape == bidirectional_mask.shape
|
||||
expanded_bidirectional_mask = _expand_mask_bloom(bidirectional_mask, tgt_length=src_length)
|
||||
combined_attention_mask = torch.logical_and(combined_attention_mask, expanded_bidirectional_mask)
|
||||
expanded_attn_mask = _expand_mask_bloom(attention_mask, tgt_length=src_length)
|
||||
combined_attention_mask = expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask | combined_attention_mask
|
||||
return combined_attention_mask
|
||||
|
||||
def _build_alibi_tensor(self: BloomModel, batch_size: int, query_length: int, key_length: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
|
||||
num_heads = self.config.n_head
|
||||
closest_power_of_2 = 2 ** math.floor(math.log2(num_heads))
|
||||
base = torch.tensor(2 ** (-2 ** (-(math.log2(closest_power_of_2) - 3))), device=device, dtype=torch.float32)
|
||||
powers = torch.arange(1, 1 + closest_power_of_2, device=device, dtype=torch.int32)
|
||||
slopes = torch.pow(base, powers)
|
||||
if closest_power_of_2 != num_heads:
|
||||
extra_base = torch.tensor(2 ** (-2 ** (-(math.log2(2 * closest_power_of_2) - 3))), device=device, dtype=torch.float32)
|
||||
num_remaining_heads = min(closest_power_of_2, num_heads - closest_power_of_2)
|
||||
extra_powers = torch.arange(1, 1 + 2 * num_remaining_heads, 2, device=device, dtype=torch.int32)
|
||||
slopes = torch.cat([slopes, torch.pow(extra_base, extra_powers)], dim=0)
|
||||
qa = torch.arange(query_length, device=device, dtype=torch.int32).view(-1, 1)
|
||||
ka = torch.arange(key_length, device=device, dtype=torch.int32).view(1, -1)
|
||||
diffs = qa - ka + key_length - query_length
|
||||
diffs = -diffs.abs()
|
||||
alibi = slopes.view(1, num_heads, 1, 1) * diffs.view(1, 1, query_length, key_length)
|
||||
alibi = alibi.expand(batch_size, -1, -1, -1).reshape(-1, query_length, key_length)
|
||||
return alibi.to(dtype)
|
||||
KeyValueT = Tuple[torch.Tensor, torch.Tensor]
|
||||
|
||||
def forward(self: BloomModel, input_ids: Optional[torch.LongTensor]=None, past_key_values: Optional[Tuple[KeyValueT, ...]]=None, attention_mask: Optional[torch.Tensor]=None, bidirectional_mask: Optional[torch.Tensor]=None, head_mask: Optional[torch.LongTensor]=None, inputs_embeds: Optional[torch.LongTensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, **deprecated_arguments) -> Union[Tuple[torch.Tensor, ...], BaseModelOutputWithPastAndCrossAttentions]:
|
||||
if deprecated_arguments.pop('position_ids', False) is not False:
|
||||
warnings.warn('`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. ' + 'You can safely ignore passing `position_ids`.', FutureWarning)
|
||||
if len(deprecated_arguments) > 0:
|
||||
raise ValueError(f'Got unexpected arguments: {deprecated_arguments}')
|
||||
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
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
||||
if input_ids is not None and inputs_embeds is not None:
|
||||
raise ValueError('You cannot specify both input_ids and inputs_embeds at the same time')
|
||||
elif input_ids is not None:
|
||||
(batch_size, seq_length) = input_ids.shape
|
||||
elif inputs_embeds is not None:
|
||||
(batch_size, seq_length, _) = inputs_embeds.shape
|
||||
else:
|
||||
raise ValueError('You have to specify either input_ids or inputs_embeds')
|
||||
if past_key_values is None:
|
||||
past_key_values = tuple([None] * len(self.h))
|
||||
head_mask = self.get_head_mask(head_mask, self.config.n_layer)
|
||||
if inputs_embeds is None:
|
||||
inputs_embeds = self.word_embeddings(input_ids)
|
||||
hidden_states = self.word_embeddings_layernorm(inputs_embeds)
|
||||
presents = () if use_cache else None
|
||||
all_self_attentions = () if output_attentions else None
|
||||
all_hidden_states = () if output_hidden_states else None
|
||||
seq_length_with_past = seq_length
|
||||
past_key_values_length = 0
|
||||
if past_key_values[0] is not None:
|
||||
tmp = past_key_values[0][0]
|
||||
past_key_values_length = tmp.shape[2]
|
||||
seq_length_with_past = seq_length_with_past + past_key_values_length
|
||||
if attention_mask is None:
|
||||
attention_mask = torch.ones((batch_size, seq_length_with_past), device=hidden_states.device)
|
||||
else:
|
||||
attention_mask = attention_mask.to(hidden_states.device)
|
||||
alibi = self._build_alibi_tensor(batch_size=batch_size, query_length=seq_length, key_length=seq_length_with_past, dtype=hidden_states.dtype, device=hidden_states.device)
|
||||
causal_mask = self._prepare_attn_mask(attention_mask, bidirectional_mask, input_shape=(batch_size, seq_length), past_key_values_length=past_key_values_length)
|
||||
for (i, (block, layer_past)) in enumerate(zip(self.h, past_key_values)):
|
||||
if output_hidden_states:
|
||||
hst = (hidden_states,)
|
||||
all_hidden_states = all_hidden_states + hst
|
||||
if self.gradient_checkpointing and self.training:
|
||||
if use_cache:
|
||||
logger.warning('`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, use_cache=use_cache, output_attentions=output_attentions)
|
||||
return custom_forward
|
||||
outputs = torch.utils.checkpoint.checkpoint(create_custom_forward(block), hidden_states, alibi, causal_mask, head_mask[i])
|
||||
else:
|
||||
outputs = block(hidden_states, layer_past=layer_past, attention_mask=causal_mask, head_mask=head_mask[i], use_cache=use_cache, output_attentions=output_attentions, alibi=alibi)
|
||||
hidden_states = outputs[0]
|
||||
if use_cache is True:
|
||||
presents = presents + (outputs[1],)
|
||||
if output_attentions:
|
||||
oa = (outputs[2 if use_cache else 1],)
|
||||
all_self_attentions = all_self_attentions + oa
|
||||
hidden_states = self.ln_f(hidden_states)
|
||||
if output_hidden_states:
|
||||
hst = (hidden_states,)
|
||||
all_hidden_states = all_hidden_states + hst
|
||||
if not return_dict:
|
||||
return tuple((v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] if v is not None))
|
||||
return BaseModelOutputWithPastAndCrossAttentions(last_hidden_state=hidden_states, past_key_values=presents, hidden_states=all_hidden_states, attentions=all_self_attentions)
|
||||
setattr(model.transformer, '_prepare_attn_mask', MethodType(_prepare_attn_mask, model.transformer))
|
||||
setattr(model.transformer, '_build_alibi_tensor', MethodType(_build_alibi_tensor, model.transformer))
|
||||
setattr(model.transformer, 'forward', MethodType(forward, model.transformer))
|
||||
KeyValueT = Tuple[torch.Tensor, torch.Tensor]
|
||||
|
||||
def forward(self: BloomForCausalLM, input_ids: Optional[torch.LongTensor]=None, past_key_values: Optional[Tuple[KeyValueT, ...]]=None, attention_mask: Optional[torch.Tensor]=None, bidirectional_mask: Optional[torch.Tensor]=None, head_mask: Optional[torch.Tensor]=None, inputs_embeds: Optional[torch.Tensor]=None, labels: Optional[torch.Tensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, **deprecated_arguments) -> Union[Tuple[torch.Tensor], CausalLMOutputWithCrossAttentions]:
|
||||
"""Replacement forward method for BloomCausalLM."""
|
||||
if deprecated_arguments.pop('position_ids', False) is not False:
|
||||
warnings.warn('`position_ids` have no functionality in BLOOM and will be removed ' + 'in v5.0.0. You can safely ignore passing `position_ids`.', FutureWarning)
|
||||
if len(deprecated_arguments) > 0:
|
||||
raise ValueError(f'Got unexpected arguments: {deprecated_arguments}')
|
||||
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
||||
transformer_outputs = self.transformer(input_ids, past_key_values=past_key_values, attention_mask=attention_mask, bidirectional_mask=bidirectional_mask, head_mask=head_mask, inputs_embeds=inputs_embeds, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
hidden_states = transformer_outputs[0]
|
||||
lm_logits = self.lm_head(hidden_states)
|
||||
loss = None
|
||||
if labels is not None:
|
||||
shift_logits = lm_logits[..., :-1, :].contiguous()
|
||||
shift_labels = labels[..., 1:].contiguous()
|
||||
(batch_size, seq_length, vocab_size) = shift_logits.shape
|
||||
loss_fct = CrossEntropyLoss()
|
||||
loss = loss_fct(shift_logits.view(batch_size * seq_length, vocab_size), shift_labels.view(batch_size * seq_length))
|
||||
if not return_dict:
|
||||
output = (lm_logits,) + transformer_outputs[1:]
|
||||
return (loss,) + output if loss is not None else output
|
||||
return CausalLMOutputWithCrossAttentions(loss=loss, logits=lm_logits, past_key_values=transformer_outputs.past_key_values, hidden_states=transformer_outputs.hidden_states, attentions=transformer_outputs.attentions)
|
||||
|
||||
def prepare_inputs_for_generation(self: BloomForCausalLM, input_ids: torch.LongTensor, past: Optional[torch.Tensor]=None, attention_mask: Optional[torch.Tensor]=None, **kwargs) -> dict:
|
||||
if past:
|
||||
input_ids = input_ids[:, -1].unsqueeze(-1)
|
||||
bidirectional_mask = None
|
||||
if past[0][0].shape[0] == input_ids.shape[0]:
|
||||
past = self._convert_to_bloom_cache(past)
|
||||
else:
|
||||
bidirectional_mask = torch.ones_like(input_ids)
|
||||
return {'input_ids': input_ids, 'past_key_values': past, 'use_cache': True, 'attention_mask': attention_mask, 'bidirectional_mask': bidirectional_mask}
|
||||
setattr(model, 'forward', MethodType(forward, model))
|
||||
setattr(model, 'prepare_inputs_for_generation', MethodType(prepare_inputs_for_generation, model))
|
||||
setattr(model, '_prefix_lm_converted', True)
|
||||
return model
|
||||
|
||||
def _convert_opt_causal_lm_to_prefix_lm(model: OPTForCausalLM) -> OPTForCausalLM:
|
||||
"""Converts an OPT Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `OPTForCausalLM`
|
||||
|
||||
See `convert_hf_causal_lm_to_prefix_lm` for more details.
|
||||
"""
|
||||
if hasattr(model, '_prefix_lm_converted'):
|
||||
return model
|
||||
assert isinstance(model, OPTForCausalLM)
|
||||
assert model.config.add_cross_attention == False, 'Only supports OPT decoder-only models'
|
||||
setattr(model, '_original_forward', getattr(model, 'forward'))
|
||||
setattr(model, '_original_generate', getattr(model, 'generate'))
|
||||
model.model.decoder.bidirectional_mask = None
|
||||
|
||||
def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
|
||||
combined_attention_mask = None
|
||||
if input_shape[-1] > 1:
|
||||
if self.bidirectional_mask == 'g':
|
||||
(bsz, src_length) = input_shape
|
||||
combined_attention_mask = torch.zeros((bsz, 1, src_length, src_length + past_key_values_length), dtype=inputs_embeds.dtype, device=inputs_embeds.device)
|
||||
else:
|
||||
combined_attention_mask = _make_causal_mask_opt(input_shape, inputs_embeds.dtype, past_key_values_length=past_key_values_length).to(inputs_embeds.device)
|
||||
if self.bidirectional_mask is not None:
|
||||
assert attention_mask.shape == self.bidirectional_mask.shape
|
||||
expanded_bidirectional_mask = _expand_mask_opt(self.bidirectional_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(inputs_embeds.device)
|
||||
combined_attention_mask = torch.maximum(expanded_bidirectional_mask, combined_attention_mask)
|
||||
if attention_mask is not None:
|
||||
expanded_attn_mask = _expand_mask_opt(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(inputs_embeds.device)
|
||||
combined_attention_mask = expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
|
||||
return combined_attention_mask
|
||||
setattr(model.model.decoder, '_prepare_decoder_attention_mask', MethodType(_prepare_decoder_attention_mask, model.model.decoder))
|
||||
|
||||
def forward(self: OPTForCausalLM, input_ids: Optional[torch.LongTensor]=None, attention_mask: Optional[torch.Tensor]=None, bidirectional_mask: Optional[torch.ByteTensor]=None, head_mask: Optional[torch.Tensor]=None, past_key_values: Optional[List[torch.FloatTensor]]=None, inputs_embeds: Optional[torch.FloatTensor]=None, labels: Optional[torch.LongTensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None):
|
||||
|
||||
def call_og_forward():
|
||||
return self._original_forward(input_ids=input_ids, attention_mask=attention_mask, head_mask=head_mask, past_key_values=past_key_values, inputs_embeds=inputs_embeds, labels=labels, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
if bidirectional_mask is None:
|
||||
return call_og_forward()
|
||||
self.model.decoder.bidirectional_mask = bidirectional_mask
|
||||
try:
|
||||
outputs = call_og_forward()
|
||||
except:
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
raise
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
return outputs
|
||||
|
||||
def generate(self: OPTForCausalLM, *args: tuple, **kwargs: Dict[str, Any]):
|
||||
"""Wraps original generate to enable PrefixLM-style attention."""
|
||||
self.model.decoder.bidirectional_mask = 'g'
|
||||
try:
|
||||
output = self._original_generate(*args, **kwargs)
|
||||
except:
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
raise
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
return output
|
||||
setattr(model, 'forward', MethodType(forward, model))
|
||||
setattr(model, 'generate', MethodType(generate, model))
|
||||
setattr(model, '_prefix_lm_converted', True)
|
||||
return model
|
||||
_SUPPORTED_HF_MODELS = _SUPPORTED_GPT_MODELS + (BloomForCausalLM, OPTForCausalLM)
|
||||
CAUSAL_LM_TYPES = Union[GPT2LMHeadModel, GPTJForCausalLM, GPTNeoForCausalLM, GPTNeoXForCausalLM, BloomForCausalLM, OPTForCausalLM]
|
||||
|
||||
def convert_hf_causal_lm_to_prefix_lm(model: CAUSAL_LM_TYPES) -> CAUSAL_LM_TYPES:
|
||||
"""Converts a HuggingFace Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `GPT2LMHeadModel`
|
||||
- `GPTNeoForCausalLM`
|
||||
- `GPTNeoXForCausalLM`
|
||||
- `GPTJForCausalLM`
|
||||
- `BloomForCausalLM`
|
||||
- `OPTForCausalLM`
|
||||
|
||||
Conversion to a Prefix LM is done by modifying the `forward` method, and possibly also the
|
||||
`generate` method and/or select underlying methods depending on the model class.
|
||||
|
||||
These changes preserve the model API, but add a new input to `forward`: "bidirectional_mask".
|
||||
|
||||
Notes on training:
|
||||
To actually train the converted model as a Prefix LM, training batches will need to indicate
|
||||
the prefix/target structure by including `bidirectional_mask` as part of the batch inputs.
|
||||
|
||||
**This is not a standard input and requires custom layers either within or after your dataloader.**
|
||||
|
||||
In addition to adding `bidirectional_mask` to the batch, this custom code should modify `labels`
|
||||
such that `batch['labels'][batch['bidirectional_mask'] == 1] == -100`.
|
||||
That is, the prefix portion of the sequence should not generate any loss. Loss should only be
|
||||
generated by the target portion of the sequence.
|
||||
|
||||
Notes on `GPTNeoForCausalLM`:
|
||||
To simplify the implementation, "global" and "local" attention layers are handled differently.
|
||||
For "global" layers, we handle conversion as described above. For "local" layers, which use a
|
||||
causal attention mask within a restricted local window, we do not alter the masking.
|
||||
|
||||
Notes on `forward` method conversion:
|
||||
After conversion, the `forward` method will handle a new input, `bidirectional_mask`,
|
||||
which should be a [batch_size, seq_length] byte tensor, where 1 indicates token positions
|
||||
belonging to the prefix (prefix tokens can attend to one another bidirectionally), and
|
||||
0 indicates token positions belonging to the target.
|
||||
|
||||
The new `forward` method will incorporate `bidirectional_mask` (if supplied) into the existing
|
||||
causal mask, call the original `forward` method, and (if the causal mask is a buffer) reset
|
||||
the causal masks before returning the result.
|
||||
|
||||
Notes on `generate` method conversion:
|
||||
After conversion, the `generate` method will have the same signature but will internally
|
||||
convert all causal masks to be purely bidirectional, call the original `generate` method, and
|
||||
(where appropriate) reset the causal masks before returning the result.
|
||||
|
||||
This works thanks to the logic of the HuggingFace `generate` API, which first encodes the token
|
||||
"prompt" passed to `generate` (which is treated as the prefix) and then sequentially generates
|
||||
each new token. Encodings are cached as generation happens, so all prefix tokens can attend to one
|
||||
another (as expected in a Prefix LM) and generated tokens can only attend to prefix tokens and
|
||||
previously-generated tokens (also as expected in a Prefix LM).
|
||||
|
||||
To preserve the API, the original methods are renamed to `_original_forward` and
|
||||
`_original_generate`, and replaced with new `forward` and `generate` methods that wrap
|
||||
them, respectively. Although implementation details vary by model class.
|
||||
"""
|
||||
if isinstance(model, _SUPPORTED_GPT_MODELS):
|
||||
return _convert_gpt_causal_lm_to_prefix_lm(model)
|
||||
elif isinstance(model, BloomForCausalLM):
|
||||
return _convert_bloom_causal_lm_to_prefix_lm(model)
|
||||
elif isinstance(model, OPTForCausalLM):
|
||||
return _convert_opt_causal_lm_to_prefix_lm(model)
|
||||
else:
|
||||
raise TypeError(f'Cannot convert model to Prefix LM. ' + f'Model does not belong to set of supported HF models:' + f'\n{_SUPPORTED_HF_MODELS}')
|
||||
|
||||
def add_bidirectional_mask_if_missing(batch: Dict[str, Any]):
|
||||
"""Attempts to add bidirectional_mask to batch if missing.
|
||||
|
||||
Raises:
|
||||
KeyError if bidirectional_mask is missing and can't be inferred
|
||||
"""
|
||||
if 'bidirectional_mask' not in batch:
|
||||
if batch.get('mode', None) == 'icl_task':
|
||||
batch['bidirectional_mask'] = batch['attention_mask'].clone()
|
||||
for (i, continuation_indices) in enumerate(batch['continuation_indices']):
|
||||
batch['bidirectional_mask'][i, continuation_indices] = 0
|
||||
elif 'labels' in batch and 'attention_mask' in batch:
|
||||
batch['bidirectional_mask'] = torch.logical_and(torch.eq(batch['attention_mask'], 1), torch.eq(batch['labels'], -100)).type_as(batch['attention_mask'])
|
||||
else:
|
||||
raise KeyError('No bidirectional_mask in batch and not sure how to construct one.')
|
||||
@@ -1,94 +0,0 @@
|
||||
from contextlib import contextmanager
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
@contextmanager
|
||||
def init_empty_weights(include_buffers: bool=False):
|
||||
"""Meta initialization context manager.
|
||||
|
||||
A context manager under which models are initialized with all parameters
|
||||
on the meta device, therefore creating an empty model. Useful when just
|
||||
initializing the model would blow the available RAM.
|
||||
|
||||
Args:
|
||||
include_buffers (`bool`, *optional*, defaults to `False`): Whether or
|
||||
not to also put all buffers on the meta device while initializing.
|
||||
|
||||
Example:
|
||||
```python
|
||||
import torch.nn as nn
|
||||
|
||||
# Initialize a model with 100 billions parameters in no time and without using any RAM.
|
||||
with init_empty_weights():
|
||||
tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])
|
||||
```
|
||||
|
||||
<Tip warning={true}>
|
||||
|
||||
Any model created under this context manager has no weights. As such you can't do something like
|
||||
`model.to(some_device)` with it. To load weights inside your empty model, see [`load_checkpoint_and_dispatch`].
|
||||
|
||||
</Tip>
|
||||
"""
|
||||
with init_on_device(torch.device('meta'), include_buffers=include_buffers) as f:
|
||||
yield f
|
||||
|
||||
@contextmanager
|
||||
def init_on_device(device: torch.device, include_buffers: bool=False):
|
||||
"""Device initialization context manager.
|
||||
|
||||
A context manager under which models are initialized with all parameters
|
||||
on the specified device.
|
||||
|
||||
Args:
|
||||
device (`torch.device`): Device to initialize all parameters on.
|
||||
include_buffers (`bool`, *optional*, defaults to `False`): Whether or
|
||||
not to also put all buffers on the meta device while initializing.
|
||||
|
||||
Example:
|
||||
```python
|
||||
import torch.nn as nn
|
||||
|
||||
with init_on_device(device=torch.device("cuda")):
|
||||
tst = nn.Liner(100, 100) # on `cuda` device
|
||||
```
|
||||
"""
|
||||
old_register_parameter = nn.Module.register_parameter
|
||||
if include_buffers:
|
||||
old_register_buffer = nn.Module.register_buffer
|
||||
|
||||
def register_empty_parameter(module, name, param):
|
||||
old_register_parameter(module, name, param)
|
||||
if param is not None:
|
||||
param_cls = type(module._parameters[name])
|
||||
kwargs = module._parameters[name].__dict__
|
||||
module._parameters[name] = param_cls(module._parameters[name].to(device), **kwargs)
|
||||
|
||||
def register_empty_buffer(module, name, buffer):
|
||||
old_register_buffer(module, name, buffer)
|
||||
if buffer is not None:
|
||||
module._buffers[name] = module._buffers[name].to(device)
|
||||
if include_buffers:
|
||||
tensor_constructors_to_patch = {torch_function_name: getattr(torch, torch_function_name) for torch_function_name in ['empty', 'zeros', 'ones', 'full']}
|
||||
else:
|
||||
tensor_constructors_to_patch = {}
|
||||
|
||||
def patch_tensor_constructor(fn):
|
||||
|
||||
def wrapper(*args, **kwargs):
|
||||
kwargs['device'] = device
|
||||
return fn(*args, **kwargs)
|
||||
return wrapper
|
||||
try:
|
||||
nn.Module.register_parameter = register_empty_parameter
|
||||
if include_buffers:
|
||||
nn.Module.register_buffer = register_empty_buffer
|
||||
for torch_function_name in tensor_constructors_to_patch.keys():
|
||||
setattr(torch, torch_function_name, patch_tensor_constructor(getattr(torch, torch_function_name)))
|
||||
yield
|
||||
finally:
|
||||
nn.Module.register_parameter = old_register_parameter
|
||||
if include_buffers:
|
||||
nn.Module.register_buffer = old_register_buffer
|
||||
for (torch_function_name, old_torch_function) in tensor_constructors_to_patch.items():
|
||||
setattr(torch, torch_function_name, old_torch_function)
|
||||
@@ -1,311 +0,0 @@
|
||||
"""A simple, flexible implementation of a GPT model.
|
||||
|
||||
Inspired by https://github.com/karpathy/minGPT/blob/master/mingpt/model.py
|
||||
"""
|
||||
import math
|
||||
import warnings
|
||||
from typing import List, Optional, Tuple, Union
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
from transformers import PreTrainedModel, PreTrainedTokenizer, PreTrainedTokenizerFast
|
||||
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
|
||||
from .attention import attn_bias_shape, build_attn_bias
|
||||
from .blocks import MPTBlock
|
||||
from .norm import NORM_CLASS_REGISTRY
|
||||
from .configuration_mpt import MPTConfig
|
||||
from .adapt_tokenizer import AutoTokenizerForMOD, adapt_tokenizer_for_denoising
|
||||
from .hf_prefixlm_converter import add_bidirectional_mask_if_missing, convert_hf_causal_lm_to_prefix_lm
|
||||
from .meta_init_context import init_empty_weights
|
||||
from .param_init_fns import MODEL_INIT_REGISTRY, generic_param_init_fn_
|
||||
Tokenizer = Union[PreTrainedTokenizer, PreTrainedTokenizerFast]
|
||||
|
||||
from transformers.utils import logging
|
||||
logger = logging.get_logger(__name__)
|
||||
|
||||
class MPTPreTrainedModel(PreTrainedModel):
|
||||
config_class = MPTConfig
|
||||
base_model_prefix = 'model'
|
||||
|
||||
class MPTModel(MPTPreTrainedModel):
|
||||
|
||||
def __init__(self, config: MPTConfig):
|
||||
config._validate_config()
|
||||
super().__init__(config)
|
||||
self.attn_impl = config.attn_config['attn_impl']
|
||||
self.prefix_lm = config.attn_config['prefix_lm']
|
||||
self.attn_uses_sequence_id = config.attn_config['attn_uses_sequence_id']
|
||||
self.alibi = config.attn_config['alibi']
|
||||
self.alibi_bias_max = config.attn_config['alibi_bias_max']
|
||||
if config.norm_type.lower() not in NORM_CLASS_REGISTRY.keys():
|
||||
norm_options = ' | '.join(NORM_CLASS_REGISTRY.keys())
|
||||
raise NotImplementedError(f'Requested norm type ({config.norm_type}) is not implemented within this repo (Options: {norm_options}).')
|
||||
norm_class = NORM_CLASS_REGISTRY[config.norm_type.lower()]
|
||||
self.embedding_fraction = config.embedding_fraction
|
||||
self.wte = nn.Embedding(config.vocab_size, config.d_model, device=config.init_device)
|
||||
if not self.alibi:
|
||||
self.wpe = nn.Embedding(config.max_seq_len, config.d_model, device=config.init_device)
|
||||
self.emb_drop = nn.Dropout(config.emb_pdrop)
|
||||
self.blocks = nn.ModuleList([MPTBlock(device=config.init_device, **config.to_dict()) for _ in range(config.n_layers)])
|
||||
self.norm_f = norm_class(config.d_model, device=config.init_device)
|
||||
if config.init_device != 'meta':
|
||||
self.apply(self.param_init_fn)
|
||||
self.is_causal = not self.prefix_lm
|
||||
self._attn_bias_initialized = False
|
||||
self.attn_bias = None
|
||||
self.attn_bias_shape = attn_bias_shape(self.attn_impl, config.n_heads, config.max_seq_len, self.alibi, prefix_lm=self.prefix_lm, causal=self.is_causal, use_sequence_id=self.attn_uses_sequence_id)
|
||||
if config.no_bias:
|
||||
for module in self.modules():
|
||||
if hasattr(module, 'bias') and isinstance(module.bias, nn.Parameter):
|
||||
if config.verbose:
|
||||
warnings.warn(f'Removing bias ({module.bias}) from {module}.')
|
||||
module.register_parameter('bias', None)
|
||||
if config.verbose and config.verbose > 2:
|
||||
print(self)
|
||||
if 'verbose' not in self.config.init_config:
|
||||
self.config.init_config['verbose'] = self.config.verbose
|
||||
if self.config.init_config['verbose'] > 1:
|
||||
init_fn_name = self.config.init_config['name']
|
||||
warnings.warn(f'Using {init_fn_name} initialization.')
|
||||
self.gradient_checkpointing = False
|
||||
|
||||
def get_input_embeddings(self):
|
||||
return self.wte
|
||||
|
||||
def set_input_embeddings(self, value):
|
||||
self.wte = value
|
||||
|
||||
@torch.no_grad()
|
||||
def _attn_bias(self, device, dtype, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None):
|
||||
if not self._attn_bias_initialized:
|
||||
if self.attn_bias_shape:
|
||||
self.attn_bias = torch.zeros(self.attn_bias_shape, device=device, dtype=dtype)
|
||||
self.attn_bias = build_attn_bias(self.attn_impl, self.attn_bias, self.config.n_heads, self.config.max_seq_len, causal=self.is_causal, alibi=self.alibi, alibi_bias_max=self.alibi_bias_max)
|
||||
self._attn_bias_initialized = True
|
||||
if self.attn_impl == 'flash':
|
||||
return (self.attn_bias, attention_mask)
|
||||
if self.attn_bias is not None:
|
||||
self.attn_bias = self.attn_bias.to(dtype=dtype, device=device)
|
||||
attn_bias = self.attn_bias
|
||||
if self.prefix_lm:
|
||||
assert isinstance(attn_bias, torch.Tensor)
|
||||
assert isinstance(prefix_mask, torch.Tensor)
|
||||
attn_bias = self._apply_prefix_mask(attn_bias, prefix_mask)
|
||||
if self.attn_uses_sequence_id and sequence_id is not None:
|
||||
assert isinstance(attn_bias, torch.Tensor)
|
||||
attn_bias = self._apply_sequence_id(attn_bias, sequence_id)
|
||||
if attention_mask is not None:
|
||||
s_k = attention_mask.shape[-1]
|
||||
if attn_bias is None:
|
||||
attn_bias = torch.zeros((1, 1, 1, s_k), device=device, dtype=dtype)
|
||||
else:
|
||||
attn_bias = attn_bias[:, :, :, -s_k:]
|
||||
if prefix_mask is not None and attention_mask.shape != prefix_mask.shape:
|
||||
raise ValueError(f'attention_mask shape={attention_mask.shape} ' + f'and prefix_mask shape={prefix_mask.shape} are not equal.')
|
||||
min_val = torch.finfo(attn_bias.dtype).min
|
||||
attn_bias = attn_bias.masked_fill(~attention_mask.view(-1, 1, 1, s_k), min_val)
|
||||
return (attn_bias, None)
|
||||
|
||||
def _apply_prefix_mask(self, attn_bias: torch.Tensor, prefix_mask: torch.Tensor):
|
||||
(s_k, s_q) = attn_bias.shape[-2:]
|
||||
if s_k != self.config.max_seq_len or s_q != self.config.max_seq_len:
|
||||
raise ValueError('attn_bias does not match the expected shape. ' + f'The last two dimensions should both be {self.config.max_length} ' + f'but are {s_k} and {s_q}.')
|
||||
seq_len = prefix_mask.shape[-1]
|
||||
if seq_len > self.config.max_seq_len:
|
||||
raise ValueError(f'prefix_mask sequence length cannot exceed max_seq_len={self.config.max_seq_len}')
|
||||
attn_bias = attn_bias[..., :seq_len, :seq_len]
|
||||
causal = torch.tril(torch.ones((seq_len, seq_len), dtype=torch.bool, device=prefix_mask.device)).view(1, 1, seq_len, seq_len)
|
||||
prefix = prefix_mask.view(-1, 1, 1, seq_len)
|
||||
cannot_attend = ~torch.logical_or(causal, prefix.bool())
|
||||
min_val = torch.finfo(attn_bias.dtype).min
|
||||
attn_bias = attn_bias.masked_fill(cannot_attend, min_val)
|
||||
return attn_bias
|
||||
|
||||
def _apply_sequence_id(self, attn_bias: torch.Tensor, sequence_id: torch.LongTensor):
|
||||
seq_len = sequence_id.shape[-1]
|
||||
if seq_len > self.config.max_seq_len:
|
||||
raise ValueError(f'sequence_id sequence length cannot exceed max_seq_len={self.config.max_seq_len}')
|
||||
attn_bias = attn_bias[..., :seq_len, :seq_len]
|
||||
cannot_attend = torch.logical_not(torch.eq(sequence_id.view(-1, seq_len, 1), sequence_id.view(-1, 1, seq_len))).unsqueeze(1)
|
||||
min_val = torch.finfo(attn_bias.dtype).min
|
||||
attn_bias = attn_bias.masked_fill(cannot_attend, min_val)
|
||||
return attn_bias
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None, tok_emb: Optional[torch.FloatTensor]=None):
|
||||
return_dict = return_dict if return_dict is not None else self.config.return_dict
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
|
||||
if self.gradient_checkpointing and self.training:
|
||||
if use_cache:
|
||||
logger.warning_once(
|
||||
"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
|
||||
)
|
||||
use_cache = False
|
||||
if attention_mask is not None:
|
||||
attention_mask = attention_mask.bool()
|
||||
if prefix_mask is not None:
|
||||
prefix_mask = prefix_mask.bool()
|
||||
if not return_dict:
|
||||
raise NotImplementedError('return_dict False is not implemented yet for MPT')
|
||||
if output_attentions:
|
||||
raise NotImplementedError('output_attentions is not implemented yet for MPT')
|
||||
if attention_mask is not None and attention_mask[:, 0].sum() != attention_mask.shape[0] and self.training:
|
||||
raise NotImplementedError('MPT does not support training with left padding.')
|
||||
if self.prefix_lm and prefix_mask is None:
|
||||
raise ValueError('prefix_mask is a required argument when MPT is configured with prefix_lm=True.')
|
||||
if self.training:
|
||||
if self.attn_uses_sequence_id and sequence_id is None:
|
||||
raise ValueError('sequence_id is a required argument when MPT is configured with attn_uses_sequence_id=True ' + 'and the model is in train mode.')
|
||||
elif self.attn_uses_sequence_id is False and sequence_id is not None:
|
||||
warnings.warn('MPT received non-None input for `sequence_id` but is configured with attn_uses_sequence_id=False. ' + 'This input will be ignored. If you want the model to use `sequence_id`, set attn_uses_sequence_id to True.')
|
||||
if input_ids is not None:
|
||||
S = input_ids.size(1)
|
||||
assert S <= self.config.max_seq_len, f'Cannot forward input with seq_len={S}, this model only supports seq_len<={self.config.max_seq_len}'
|
||||
tok_emb = self.wte(input_ids)
|
||||
else:
|
||||
assert tok_emb is not None
|
||||
S = tok_emb.size(1)
|
||||
if self.alibi:
|
||||
x = tok_emb
|
||||
else:
|
||||
past_position = 0
|
||||
if past_key_values is not None:
|
||||
if len(past_key_values) != self.config.n_layers:
|
||||
raise ValueError(f'past_key_values must provide a past_key_value for each attention ' + f'layer in the network (len(past_key_values)={len(past_key_values)!r}; self.config.n_layers={self.config.n_layers!r}).')
|
||||
past_position = past_key_values[0][0].size(1)
|
||||
if S + past_position > self.config.max_seq_len:
|
||||
raise ValueError(f'Cannot forward input with past sequence length {past_position} and current sequence length {S + 1}, this model only supports total sequence length <= {self.config.max_seq_len}.')
|
||||
pos = torch.arange(past_position, S + past_position, dtype=torch.long, device=input_ids.device).unsqueeze(0)
|
||||
if attention_mask is not None:
|
||||
pos = torch.clamp(pos - torch.cumsum((~attention_mask).to(torch.int32), dim=1)[:, past_position:], min=0)
|
||||
pos_emb = self.wpe(pos)
|
||||
x = tok_emb + pos_emb
|
||||
if self.embedding_fraction == 1:
|
||||
x = self.emb_drop(x)
|
||||
else:
|
||||
x_shrunk = x * self.embedding_fraction + x.detach() * (1 - self.embedding_fraction)
|
||||
assert isinstance(self.emb_drop, nn.Module)
|
||||
x = self.emb_drop(x_shrunk)
|
||||
(attn_bias, attention_mask) = self._attn_bias(device=x.device, dtype=x.dtype, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id)
|
||||
if use_cache and past_key_values is None:
|
||||
past_key_values = [() for _ in range(self.config.n_layers)]
|
||||
all_hidden_states = () if output_hidden_states else None
|
||||
for (b_idx, block) in enumerate(self.blocks):
|
||||
if output_hidden_states:
|
||||
assert all_hidden_states is not None
|
||||
all_hidden_states = all_hidden_states + (x,)
|
||||
past_key_value = past_key_values[b_idx] if past_key_values is not None else None
|
||||
if self.gradient_checkpointing and self.training:
|
||||
(x, past_key_value) = torch.utils.checkpoint.checkpoint(
|
||||
block,
|
||||
x, past_key_value, attn_bias, attention_mask, self.is_causal
|
||||
)
|
||||
else:
|
||||
(x, past_key_value) = block(x, past_key_value=past_key_value, attn_bias=attn_bias, attention_mask=attention_mask, is_causal=self.is_causal)
|
||||
if past_key_values is not None:
|
||||
past_key_values[b_idx] = past_key_value
|
||||
x = self.norm_f(x)
|
||||
return BaseModelOutputWithPast(last_hidden_state=x, past_key_values=past_key_values, hidden_states=all_hidden_states)
|
||||
|
||||
def param_init_fn(self, module):
|
||||
init_fn_name = self.config.init_config['name']
|
||||
MODEL_INIT_REGISTRY[init_fn_name](module=module, n_layers=self.config.n_layers, d_model=self.config.d_model, **self.config.init_config)
|
||||
|
||||
def fsdp_wrap_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
def activation_checkpointing_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
class MPTForCausalLM(MPTPreTrainedModel):
|
||||
|
||||
def __init__(self, config: MPTConfig):
|
||||
super().__init__(config)
|
||||
if not config.tie_word_embeddings:
|
||||
raise ValueError('MPTForCausalLM only supports tied word embeddings')
|
||||
self.transformer = MPTModel(config)
|
||||
self.logit_scale = None
|
||||
if config.logit_scale is not None:
|
||||
logit_scale = config.logit_scale
|
||||
if isinstance(logit_scale, str):
|
||||
if logit_scale == 'inv_sqrt_d_model':
|
||||
logit_scale = 1 / math.sqrt(config.d_model)
|
||||
else:
|
||||
raise ValueError(f"logit_scale={logit_scale!r} is not recognized as an option; use numeric value or 'inv_sqrt_d_model'.")
|
||||
self.logit_scale = logit_scale
|
||||
|
||||
def get_input_embeddings(self):
|
||||
return self.transformer.wte
|
||||
|
||||
def set_input_embeddings(self, value):
|
||||
self.transformer.wte = value
|
||||
|
||||
def get_output_embeddings(self):
|
||||
return self.transformer.wte
|
||||
|
||||
def set_output_embeddings(self, new_embeddings):
|
||||
self.transformer.wte = new_embeddings
|
||||
|
||||
def set_decoder(self, decoder):
|
||||
self.transformer = decoder
|
||||
|
||||
def get_decoder(self):
|
||||
return self.transformer
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, labels: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None):
|
||||
return_dict = return_dict if return_dict is not None else self.config.return_dict
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
outputs = self.transformer(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id, return_dict=return_dict, output_attentions=output_attentions, output_hidden_states=output_hidden_states, use_cache=use_cache)
|
||||
logits = F.linear(outputs.last_hidden_state, self.transformer.wte.weight)
|
||||
if self.logit_scale is not None:
|
||||
if self.logit_scale == 0:
|
||||
warnings.warn(f'Multiplying logits by self.logit_scale={self.logit_scale!r}. This will produce uniform (uninformative) outputs.')
|
||||
logits *= self.logit_scale
|
||||
loss = None
|
||||
if labels is not None:
|
||||
labels = torch.roll(labels, shifts=-1)
|
||||
labels[:, -1] = -100
|
||||
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), labels.to(logits.device).view(-1))
|
||||
return CausalLMOutputWithPast(loss=loss, logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states)
|
||||
|
||||
def param_init_fn(self, module):
|
||||
init_fn_name = self.config.init_config['name']
|
||||
MODEL_INIT_REGISTRY[init_fn_name](module=module, n_layers=self.config.n_layers, d_model=self.config.d_model, **self.config.init_config)
|
||||
|
||||
def fsdp_wrap_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
def activation_checkpointing_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
|
||||
if inputs_embeds is not None:
|
||||
raise NotImplementedError('inputs_embeds is not implemented for MPT yet')
|
||||
attention_mask = kwargs['attention_mask'].bool()
|
||||
if attention_mask[:, -1].sum() != attention_mask.shape[0]:
|
||||
raise NotImplementedError('MPT does not support generation with right padding.')
|
||||
if self.transformer.attn_uses_sequence_id and self.training:
|
||||
sequence_id = torch.zeros_like(input_ids[:1])
|
||||
else:
|
||||
sequence_id = None
|
||||
if past_key_values is not None:
|
||||
input_ids = input_ids[:, -1].unsqueeze(-1)
|
||||
if self.transformer.prefix_lm:
|
||||
prefix_mask = torch.ones_like(attention_mask)
|
||||
if kwargs.get('use_cache') == False:
|
||||
raise NotImplementedError('MPT with prefix_lm=True does not support use_cache=False.')
|
||||
else:
|
||||
prefix_mask = None
|
||||
return {'input_ids': input_ids, 'attention_mask': attention_mask, 'prefix_mask': prefix_mask, 'sequence_id': sequence_id, 'past_key_values': past_key_values, 'use_cache': kwargs.get('use_cache', True)}
|
||||
|
||||
@staticmethod
|
||||
def _reorder_cache(past_key_values, beam_idx):
|
||||
"""Used by HuggingFace generate when using beam search with kv-caching.
|
||||
|
||||
See https://github.com/huggingface/transformers/blob/3ec7a47664ebe40c40f4b722f6bb1cd30c3821ec/src/transformers/models/gpt2/modeling_gpt2.py#L1122-L1133
|
||||
for an example in transformers.
|
||||
"""
|
||||
reordered_past = []
|
||||
for layer_past in past_key_values:
|
||||
reordered_past += [tuple((past_state.index_select(0, beam_idx) for past_state in layer_past))]
|
||||
return reordered_past
|
||||
@@ -1,56 +0,0 @@
|
||||
import torch
|
||||
|
||||
def _cast_if_autocast_enabled(tensor):
|
||||
if torch.is_autocast_enabled():
|
||||
if tensor.device.type == 'cuda':
|
||||
dtype = torch.get_autocast_gpu_dtype()
|
||||
elif tensor.device.type == 'cpu':
|
||||
dtype = torch.get_autocast_cpu_dtype()
|
||||
else:
|
||||
raise NotImplementedError()
|
||||
return tensor.to(dtype=dtype)
|
||||
return tensor
|
||||
|
||||
class LPLayerNorm(torch.nn.LayerNorm):
|
||||
|
||||
def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True, device=None, dtype=None):
|
||||
super().__init__(normalized_shape=normalized_shape, eps=eps, elementwise_affine=elementwise_affine, device=device, dtype=dtype)
|
||||
|
||||
def forward(self, x):
|
||||
module_device = x.device
|
||||
downcast_x = _cast_if_autocast_enabled(x)
|
||||
downcast_weight = _cast_if_autocast_enabled(self.weight) if self.weight is not None else self.weight
|
||||
downcast_bias = _cast_if_autocast_enabled(self.bias) if self.bias is not None else self.bias
|
||||
with torch.autocast(enabled=False, device_type=module_device.type):
|
||||
return torch.nn.functional.layer_norm(downcast_x, self.normalized_shape, downcast_weight, downcast_bias, self.eps)
|
||||
|
||||
def rms_norm(x, weight=None, eps=1e-05):
|
||||
output = x / torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
|
||||
if weight is not None:
|
||||
return output * weight
|
||||
return output
|
||||
|
||||
class RMSNorm(torch.nn.Module):
|
||||
|
||||
def __init__(self, normalized_shape, eps=1e-05, weight=True, dtype=None, device=None):
|
||||
super().__init__()
|
||||
self.eps = eps
|
||||
if weight:
|
||||
self.weight = torch.nn.Parameter(torch.ones(normalized_shape, dtype=dtype, device=device))
|
||||
else:
|
||||
self.register_parameter('weight', None)
|
||||
|
||||
def forward(self, x):
|
||||
return rms_norm(x.float(), self.weight, self.eps).to(dtype=x.dtype)
|
||||
|
||||
class LPRMSNorm(RMSNorm):
|
||||
|
||||
def __init__(self, normalized_shape, eps=1e-05, weight=True, dtype=None, device=None):
|
||||
super().__init__(normalized_shape=normalized_shape, eps=eps, weight=weight, dtype=dtype, device=device)
|
||||
|
||||
def forward(self, x):
|
||||
downcast_x = _cast_if_autocast_enabled(x)
|
||||
downcast_weight = _cast_if_autocast_enabled(self.weight) if self.weight is not None else self.weight
|
||||
with torch.autocast(enabled=False, device_type=x.device.type):
|
||||
return rms_norm(downcast_x, downcast_weight, self.eps).to(dtype=x.dtype)
|
||||
NORM_CLASS_REGISTRY = {'layernorm': torch.nn.LayerNorm, 'low_precision_layernorm': LPLayerNorm, 'rmsnorm': RMSNorm, 'low_precision_rmsnorm': LPRMSNorm}
|
||||
@@ -1,181 +0,0 @@
|
||||
import math
|
||||
import warnings
|
||||
from collections.abc import Sequence
|
||||
from functools import partial
|
||||
from typing import Optional, Tuple, Union
|
||||
import torch
|
||||
from torch import nn
|
||||
from .norm import NORM_CLASS_REGISTRY
|
||||
|
||||
def torch_default_param_init_fn_(module: nn.Module, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f"Initializing network using module's reset_parameters attribute")
|
||||
if hasattr(module, 'reset_parameters'):
|
||||
module.reset_parameters()
|
||||
|
||||
def fused_init_helper_(module: nn.Module, init_fn_):
|
||||
_fused = getattr(module, '_fused', None)
|
||||
if _fused is None:
|
||||
raise RuntimeError(f'Internal logic error')
|
||||
(dim, splits) = _fused
|
||||
splits = (0, *splits, module.weight.size(dim))
|
||||
for (s, e) in zip(splits[:-1], splits[1:]):
|
||||
slice_indices = [slice(None)] * module.weight.ndim
|
||||
slice_indices[dim] = slice(s, e)
|
||||
init_fn_(module.weight[slice_indices])
|
||||
|
||||
def generic_param_init_fn_(module: nn.Module, init_fn_, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f'If model has bias parameters they are initialized to 0.')
|
||||
init_div_is_residual = init_div_is_residual
|
||||
if init_div_is_residual is False:
|
||||
div_is_residual = 1.0
|
||||
elif init_div_is_residual is True:
|
||||
div_is_residual = math.sqrt(2 * n_layers)
|
||||
elif isinstance(init_div_is_residual, float) or isinstance(init_div_is_residual, int):
|
||||
div_is_residual = init_div_is_residual
|
||||
elif isinstance(init_div_is_residual, str) and init_div_is_residual.isnumeric():
|
||||
div_is_residual = float(init_div_is_residual)
|
||||
else:
|
||||
div_is_residual = 1.0
|
||||
raise ValueError(f'Expected init_div_is_residual to be boolean or numeric, got {init_div_is_residual}')
|
||||
if init_div_is_residual is not False:
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Initializing _is_residual layers then dividing them by {div_is_residual:.3f}. ' + f'Set `init_div_is_residual: false` in init config to disable this.')
|
||||
if isinstance(module, nn.Linear):
|
||||
if hasattr(module, '_fused'):
|
||||
fused_init_helper_(module, init_fn_)
|
||||
else:
|
||||
init_fn_(module.weight)
|
||||
if module.bias is not None:
|
||||
torch.nn.init.zeros_(module.bias)
|
||||
if init_div_is_residual is not False and getattr(module, '_is_residual', False):
|
||||
with torch.no_grad():
|
||||
module.weight.div_(div_is_residual)
|
||||
elif isinstance(module, nn.Embedding):
|
||||
if emb_init_std is not None:
|
||||
std = emb_init_std
|
||||
if std == 0:
|
||||
warnings.warn(f'Embedding layer initialized to 0.')
|
||||
emb_init_fn_ = partial(torch.nn.init.normal_, mean=0.0, std=std)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Embedding layer initialized using normal distribution with mean=0 and std={std!r}.')
|
||||
elif emb_init_uniform_lim is not None:
|
||||
lim = emb_init_uniform_lim
|
||||
if isinstance(lim, Sequence):
|
||||
if len(lim) > 2:
|
||||
raise ValueError(f'Uniform init requires a min and a max limit. User input: {lim}.')
|
||||
if lim[0] == lim[1]:
|
||||
warnings.warn(f'Embedding layer initialized to {lim[0]}.')
|
||||
else:
|
||||
if lim == 0:
|
||||
warnings.warn(f'Embedding layer initialized to 0.')
|
||||
lim = [-lim, lim]
|
||||
(a, b) = lim
|
||||
emb_init_fn_ = partial(torch.nn.init.uniform_, a=a, b=b)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Embedding layer initialized using uniform distribution in range {lim}.')
|
||||
else:
|
||||
emb_init_fn_ = init_fn_
|
||||
emb_init_fn_(module.weight)
|
||||
elif isinstance(module, tuple(set(NORM_CLASS_REGISTRY.values()))):
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Norm weights are set to 1. If norm layer has a bias it is initialized to 0.')
|
||||
if hasattr(module, 'weight') and module.weight is not None:
|
||||
torch.nn.init.ones_(module.weight)
|
||||
if hasattr(module, 'bias') and module.bias is not None:
|
||||
torch.nn.init.zeros_(module.bias)
|
||||
elif isinstance(module, nn.MultiheadAttention):
|
||||
if module._qkv_same_embed_dim:
|
||||
assert module.in_proj_weight is not None
|
||||
assert module.q_proj_weight is None and module.k_proj_weight is None and (module.v_proj_weight is None)
|
||||
assert d_model is not None
|
||||
_d = d_model
|
||||
splits = (0, _d, 2 * _d, 3 * _d)
|
||||
for (s, e) in zip(splits[:-1], splits[1:]):
|
||||
init_fn_(module.in_proj_weight[s:e])
|
||||
else:
|
||||
assert module.q_proj_weight is not None and module.k_proj_weight is not None and (module.v_proj_weight is not None)
|
||||
assert module.in_proj_weight is None
|
||||
init_fn_(module.q_proj_weight)
|
||||
init_fn_(module.k_proj_weight)
|
||||
init_fn_(module.v_proj_weight)
|
||||
if module.in_proj_bias is not None:
|
||||
torch.nn.init.zeros_(module.in_proj_bias)
|
||||
if module.bias_k is not None:
|
||||
torch.nn.init.zeros_(module.bias_k)
|
||||
if module.bias_v is not None:
|
||||
torch.nn.init.zeros_(module.bias_v)
|
||||
init_fn_(module.out_proj.weight)
|
||||
if init_div_is_residual is not False and getattr(module.out_proj, '_is_residual', False):
|
||||
with torch.no_grad():
|
||||
module.out_proj.weight.div_(div_is_residual)
|
||||
if module.out_proj.bias is not None:
|
||||
torch.nn.init.zeros_(module.out_proj.bias)
|
||||
else:
|
||||
for _ in module.parameters(recurse=False):
|
||||
raise NotImplementedError(f'{module.__class__.__name__} parameters are not initialized by param_init_fn.')
|
||||
|
||||
def _normal_init_(std, mean=0.0):
|
||||
return partial(torch.nn.init.normal_, mean=mean, std=std)
|
||||
|
||||
def _normal_param_init_fn_(module: nn.Module, std: float, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
init_fn_ = _normal_init_(std=std)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using torch.nn.init.normal_ init fn mean=0.0, std={std}')
|
||||
generic_param_init_fn_(module=module, init_fn_=init_fn_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def baseline_param_init_fn_(module: nn.Module, init_std: float, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if init_std is None:
|
||||
raise ValueError("You must set model.init_config['init_std'] to a float value to use the default initialization scheme.")
|
||||
_normal_param_init_fn_(module=module, std=init_std, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def small_param_init_fn_(module: nn.Module, n_layers: int, d_model: int, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
std = math.sqrt(2 / (5 * d_model))
|
||||
_normal_param_init_fn_(module=module, std=std, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def neox_param_init_fn_(module: nn.Module, n_layers: int, d_model: int, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
"""From section 2.3.1 of GPT-NeoX-20B:
|
||||
|
||||
An Open-Source AutoregressiveLanguage Model — Black et. al. (2022)
|
||||
see https://github.com/EleutherAI/gpt-neox/blob/9610391ab319403cef079b438edd016a2443af54/megatron/model/init_functions.py#L151
|
||||
and https://github.com/EleutherAI/gpt-neox/blob/main/megatron/model/transformer.py
|
||||
"""
|
||||
del kwargs
|
||||
residual_div = n_layers / math.sqrt(10)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'setting init_div_is_residual to {residual_div}')
|
||||
small_param_init_fn_(module=module, d_model=d_model, n_layers=n_layers, init_div_is_residual=residual_div, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def kaiming_uniform_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, fan_mode: str='fan_in', init_nonlinearity: str='leaky_relu', verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using nn.init.kaiming_uniform_ init fn with parameters: ' + f'a={init_gain}, mode={fan_mode}, nonlinearity={init_nonlinearity}')
|
||||
kaiming_uniform_ = partial(nn.init.kaiming_uniform_, a=init_gain, mode=fan_mode, nonlinearity=init_nonlinearity)
|
||||
generic_param_init_fn_(module=module, init_fn_=kaiming_uniform_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def kaiming_normal_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, fan_mode: str='fan_in', init_nonlinearity: str='leaky_relu', verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using nn.init.kaiming_normal_ init fn with parameters: ' + f'a={init_gain}, mode={fan_mode}, nonlinearity={init_nonlinearity}')
|
||||
kaiming_normal_ = partial(torch.nn.init.kaiming_normal_, a=init_gain, mode=fan_mode, nonlinearity=init_nonlinearity)
|
||||
generic_param_init_fn_(module=module, init_fn_=kaiming_normal_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def xavier_uniform_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
xavier_uniform_ = partial(torch.nn.init.xavier_uniform_, gain=init_gain)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using torch.nn.init.xavier_uniform_ init fn with parameters: ' + f'gain={init_gain}')
|
||||
generic_param_init_fn_(module=module, init_fn_=xavier_uniform_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def xavier_normal_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, verbose: int=0, **kwargs):
|
||||
xavier_normal_ = partial(torch.nn.init.xavier_normal_, gain=init_gain)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using torch.nn.init.xavier_normal_ init fn with parameters: ' + f'gain={init_gain}')
|
||||
generic_param_init_fn_(module=module, init_fn_=xavier_normal_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
MODEL_INIT_REGISTRY = {'default_': torch_default_param_init_fn_, 'baseline_': baseline_param_init_fn_, 'kaiming_uniform_': kaiming_uniform_param_init_fn_, 'kaiming_normal_': kaiming_normal_param_init_fn_, 'neox_init_': neox_param_init_fn_, 'small_init_': small_param_init_fn_, 'xavier_uniform_': xavier_uniform_param_init_fn_, 'xavier_normal_': xavier_normal_param_init_fn_}
|
||||
@@ -1,46 +0,0 @@
|
||||
import torch
|
||||
from llava.model import *
|
||||
from transformers import AutoConfig, StoppingCriteria
|
||||
|
||||
|
||||
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)
|
||||
|
||||
|
||||
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.keyword_ids = [tokenizer(keyword).input_ids for keyword in keywords]
|
||||
self.keyword_ids = [keyword_id[0] for keyword_id in self.keyword_ids if type(keyword_id) is list and len(keyword_id) == 1]
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
for keyword_id in self.keyword_ids:
|
||||
if output_ids[0, -1] == keyword_id:
|
||||
return True
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
@@ -1,153 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.serve.cli --model ~/model_weights/llama-7b
|
||||
"""
|
||||
import argparse
|
||||
import time
|
||||
|
||||
import torch
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
|
||||
from llava.conversation import conv_templates, SeparatorStyle
|
||||
|
||||
|
||||
@torch.inference_mode()
|
||||
def generate_stream(tokenizer, model, params, device,
|
||||
context_len=2048, stream_interval=2):
|
||||
"""Adapted from fastchat/serve/model_worker.py::generate_stream"""
|
||||
|
||||
prompt = params["prompt"]
|
||||
l_prompt = len(prompt)
|
||||
temperature = float(params.get("temperature", 1.0))
|
||||
max_new_tokens = int(params.get("max_new_tokens", 256))
|
||||
stop_str = params.get("stop", None)
|
||||
|
||||
input_ids = tokenizer(prompt).input_ids
|
||||
output_ids = list(input_ids)
|
||||
|
||||
max_src_len = context_len - max_new_tokens - 8
|
||||
input_ids = input_ids[-max_src_len:]
|
||||
|
||||
for i in range(max_new_tokens):
|
||||
if i == 0:
|
||||
out = model(
|
||||
torch.as_tensor([input_ids], device=device), use_cache=True)
|
||||
logits = out.logits
|
||||
past_key_values = out.past_key_values
|
||||
else:
|
||||
attention_mask = torch.ones(
|
||||
1, past_key_values[0][0].shape[-2] + 1, device=device)
|
||||
out = model(input_ids=torch.as_tensor([[token]], device=device),
|
||||
use_cache=True,
|
||||
attention_mask=attention_mask,
|
||||
past_key_values=past_key_values)
|
||||
logits = out.logits
|
||||
past_key_values = out.past_key_values
|
||||
|
||||
last_token_logits = logits[0][-1]
|
||||
if temperature < 1e-4:
|
||||
token = int(torch.argmax(last_token_logits))
|
||||
else:
|
||||
probs = torch.softmax(last_token_logits / temperature, dim=-1)
|
||||
token = int(torch.multinomial(probs, num_samples=1))
|
||||
|
||||
output_ids.append(token)
|
||||
|
||||
if token == tokenizer.eos_token_id:
|
||||
stopped = True
|
||||
else:
|
||||
stopped = False
|
||||
|
||||
if i % stream_interval == 0 or i == max_new_tokens - 1 or stopped:
|
||||
output = tokenizer.decode(output_ids, skip_special_tokens=True)
|
||||
pos = output.rfind(stop_str, l_prompt)
|
||||
if pos != -1:
|
||||
output = output[:pos]
|
||||
stopped = True
|
||||
yield output
|
||||
|
||||
if stopped:
|
||||
break
|
||||
|
||||
del past_key_values
|
||||
|
||||
|
||||
def main(args):
|
||||
model_name = args.model_name
|
||||
num_gpus = args.num_gpus
|
||||
|
||||
# Model
|
||||
if args.device == "cuda":
|
||||
kwargs = {"torch_dtype": torch.float16}
|
||||
if num_gpus == "auto":
|
||||
kwargs["device_map"] = "auto"
|
||||
else:
|
||||
num_gpus = int(num_gpus)
|
||||
if num_gpus != 1:
|
||||
kwargs.update({
|
||||
"device_map": "auto",
|
||||
"max_memory": {i: "13GiB" for i in range(num_gpus)},
|
||||
})
|
||||
elif args.device == "cpu":
|
||||
kwargs = {}
|
||||
else:
|
||||
raise ValueError(f"Invalid device: {args.device}")
|
||||
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
model = AutoModelForCausalLM.from_pretrained(model_name,
|
||||
low_cpu_mem_usage=True, **kwargs)
|
||||
|
||||
if args.device == "cuda" and num_gpus == 1:
|
||||
model.cuda()
|
||||
|
||||
# Chat
|
||||
conv = conv_templates[args.conv_template].copy()
|
||||
while True:
|
||||
try:
|
||||
inp = input(f"{conv.roles[0]}: ")
|
||||
except EOFError:
|
||||
inp = ""
|
||||
if not inp:
|
||||
print("exit...")
|
||||
break
|
||||
|
||||
conv.append_message(conv.roles[0], inp)
|
||||
conv.append_message(conv.roles[1], None)
|
||||
prompt = conv.get_prompt()
|
||||
|
||||
params = {
|
||||
"model": model_name,
|
||||
"prompt": prompt,
|
||||
"temperature": args.temperature,
|
||||
"max_new_tokens": args.max_new_tokens,
|
||||
"stop": conv.sep if conv.sep_style == SeparatorStyle.SINGLE else conv.sep2,
|
||||
}
|
||||
|
||||
print(f"{conv.roles[1]}: ", end="", flush=True)
|
||||
pre = 0
|
||||
for outputs in generate_stream(tokenizer, model, params, args.device):
|
||||
outputs = outputs[len(prompt) + 1:].strip()
|
||||
outputs = outputs.split(" ")
|
||||
now = len(outputs)
|
||||
if now - 1 > pre:
|
||||
print(" ".join(outputs[pre:now-1]), end=" ", flush=True)
|
||||
pre = now - 1
|
||||
print(" ".join(outputs[pre:]), flush=True)
|
||||
|
||||
conv.messages[-1][-1] = " ".join(outputs)
|
||||
|
||||
if args.debug:
|
||||
print("\n", {"prompt": prompt, "outputs": outputs}, "\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--num-gpus", type=str, default="1")
|
||||
parser.add_argument("--device", type=str, choices=["cuda", "cpu"], default="cuda")
|
||||
parser.add_argument("--conv-template", type=str, default="v1")
|
||||
parser.add_argument("--temperature", type=float, default=0.7)
|
||||
parser.add_argument("--max-new-tokens", type=int, default=512)
|
||||
parser.add_argument("--debug", action="store_true")
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
@@ -1,298 +0,0 @@
|
||||
"""
|
||||
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")
|
||||
@@ -1,73 +0,0 @@
|
||||
code_highlight_css = (
|
||||
"""
|
||||
#chatbot .hll { background-color: #ffffcc }
|
||||
#chatbot .c { color: #408080; font-style: italic }
|
||||
#chatbot .err { border: 1px solid #FF0000 }
|
||||
#chatbot .k { color: #008000; font-weight: bold }
|
||||
#chatbot .o { color: #666666 }
|
||||
#chatbot .ch { color: #408080; font-style: italic }
|
||||
#chatbot .cm { color: #408080; font-style: italic }
|
||||
#chatbot .cp { color: #BC7A00 }
|
||||
#chatbot .cpf { color: #408080; font-style: italic }
|
||||
#chatbot .c1 { color: #408080; font-style: italic }
|
||||
#chatbot .cs { color: #408080; font-style: italic }
|
||||
#chatbot .gd { color: #A00000 }
|
||||
#chatbot .ge { font-style: italic }
|
||||
#chatbot .gr { color: #FF0000 }
|
||||
#chatbot .gh { color: #000080; font-weight: bold }
|
||||
#chatbot .gi { color: #00A000 }
|
||||
#chatbot .go { color: #888888 }
|
||||
#chatbot .gp { color: #000080; font-weight: bold }
|
||||
#chatbot .gs { font-weight: bold }
|
||||
#chatbot .gu { color: #800080; font-weight: bold }
|
||||
#chatbot .gt { color: #0044DD }
|
||||
#chatbot .kc { color: #008000; font-weight: bold }
|
||||
#chatbot .kd { color: #008000; font-weight: bold }
|
||||
#chatbot .kn { color: #008000; font-weight: bold }
|
||||
#chatbot .kp { color: #008000 }
|
||||
#chatbot .kr { color: #008000; font-weight: bold }
|
||||
#chatbot .kt { color: #B00040 }
|
||||
#chatbot .m { color: #666666 }
|
||||
#chatbot .s { color: #BA2121 }
|
||||
#chatbot .na { color: #7D9029 }
|
||||
#chatbot .nb { color: #008000 }
|
||||
#chatbot .nc { color: #0000FF; font-weight: bold }
|
||||
#chatbot .no { color: #880000 }
|
||||
#chatbot .nd { color: #AA22FF }
|
||||
#chatbot .ni { color: #999999; font-weight: bold }
|
||||
#chatbot .ne { color: #D2413A; font-weight: bold }
|
||||
#chatbot .nf { color: #0000FF }
|
||||
#chatbot .nl { color: #A0A000 }
|
||||
#chatbot .nn { color: #0000FF; font-weight: bold }
|
||||
#chatbot .nt { color: #008000; font-weight: bold }
|
||||
#chatbot .nv { color: #19177C }
|
||||
#chatbot .ow { color: #AA22FF; font-weight: bold }
|
||||
#chatbot .w { color: #bbbbbb }
|
||||
#chatbot .mb { color: #666666 }
|
||||
#chatbot .mf { color: #666666 }
|
||||
#chatbot .mh { color: #666666 }
|
||||
#chatbot .mi { color: #666666 }
|
||||
#chatbot .mo { color: #666666 }
|
||||
#chatbot .sa { color: #BA2121 }
|
||||
#chatbot .sb { color: #BA2121 }
|
||||
#chatbot .sc { color: #BA2121 }
|
||||
#chatbot .dl { color: #BA2121 }
|
||||
#chatbot .sd { color: #BA2121; font-style: italic }
|
||||
#chatbot .s2 { color: #BA2121 }
|
||||
#chatbot .se { color: #BB6622; font-weight: bold }
|
||||
#chatbot .sh { color: #BA2121 }
|
||||
#chatbot .si { color: #BB6688; font-weight: bold }
|
||||
#chatbot .sx { color: #008000 }
|
||||
#chatbot .sr { color: #BB6688 }
|
||||
#chatbot .s1 { color: #BA2121 }
|
||||
#chatbot .ss { color: #19177C }
|
||||
#chatbot .bp { color: #008000 }
|
||||
#chatbot .fm { color: #0000FF }
|
||||
#chatbot .vc { color: #19177C }
|
||||
#chatbot .vg { color: #19177C }
|
||||
#chatbot .vi { color: #19177C }
|
||||
#chatbot .vm { color: #19177C }
|
||||
#chatbot .il { color: #666666 }
|
||||
""")
|
||||
#.highlight { background: #f8f8f8; }
|
||||
|
||||
@@ -1,168 +0,0 @@
|
||||
"""
|
||||
Adopted from https://github.com/gradio-app/gradio/blob/main/gradio/components.py
|
||||
Fix a markdown render problem.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from gradio.components import *
|
||||
from markdown2 import Markdown
|
||||
|
||||
|
||||
class _Keywords(Enum):
|
||||
NO_VALUE = "NO_VALUE" # Used as a sentinel to determine if nothing is provided as a argument for `value` in `Component.update()`
|
||||
FINISHED_ITERATING = "FINISHED_ITERATING" # Used to skip processing of a component's value (needed for generators + state)
|
||||
|
||||
|
||||
@document("style")
|
||||
class Chatbot(Changeable, Selectable, IOComponent, JSONSerializable):
|
||||
"""
|
||||
Displays a chatbot output showing both user submitted messages and responses. Supports a subset of Markdown including bold, italics, code, and images.
|
||||
Preprocessing: this component does *not* accept input.
|
||||
Postprocessing: expects function to return a {List[Tuple[str | None | Tuple, str | None | Tuple]]}, a list of tuples with user message and response messages. Messages should be strings, tuples, or Nones. If the message is a string, it can include Markdown. If it is a tuple, it should consist of (string filepath to image/video/audio, [optional string alt text]). Messages that are `None` are not displayed.
|
||||
|
||||
Demos: chatbot_simple, chatbot_multimodal
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
value: List[Tuple[str | None, str | None]] | Callable | None = None,
|
||||
color_map: Dict[str, str] | None = None, # Parameter moved to Chatbot.style()
|
||||
*,
|
||||
label: str | None = None,
|
||||
every: float | None = None,
|
||||
show_label: bool = True,
|
||||
visible: bool = True,
|
||||
elem_id: str | None = None,
|
||||
elem_classes: List[str] | str | None = None,
|
||||
**kwargs,
|
||||
):
|
||||
"""
|
||||
Parameters:
|
||||
value: Default value to show in chatbot. If callable, the function will be called whenever the app loads to set the initial value of the component.
|
||||
label: component name in interface.
|
||||
every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
|
||||
show_label: if True, will display label.
|
||||
visible: If False, component will be hidden.
|
||||
elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
|
||||
elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
|
||||
"""
|
||||
if color_map is not None:
|
||||
warnings.warn(
|
||||
"The 'color_map' parameter has been deprecated.",
|
||||
)
|
||||
#self.md = utils.get_markdown_parser()
|
||||
self.md = Markdown(extras=["fenced-code-blocks", "tables", "break-on-newline"])
|
||||
self.select: EventListenerMethod
|
||||
"""
|
||||
Event listener for when the user selects message from Chatbot.
|
||||
Uses event data gradio.SelectData to carry `value` referring to text of selected message, and `index` tuple to refer to [message, participant] index.
|
||||
See EventData documentation on how to use this event data.
|
||||
"""
|
||||
|
||||
IOComponent.__init__(
|
||||
self,
|
||||
label=label,
|
||||
every=every,
|
||||
show_label=show_label,
|
||||
visible=visible,
|
||||
elem_id=elem_id,
|
||||
elem_classes=elem_classes,
|
||||
value=value,
|
||||
**kwargs,
|
||||
)
|
||||
|
||||
def get_config(self):
|
||||
return {
|
||||
"value": self.value,
|
||||
"selectable": self.selectable,
|
||||
**IOComponent.get_config(self),
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def update(
|
||||
value: Any | Literal[_Keywords.NO_VALUE] | None = _Keywords.NO_VALUE,
|
||||
label: str | None = None,
|
||||
show_label: bool | None = None,
|
||||
visible: bool | None = None,
|
||||
):
|
||||
updated_config = {
|
||||
"label": label,
|
||||
"show_label": show_label,
|
||||
"visible": visible,
|
||||
"value": value,
|
||||
"__type__": "update",
|
||||
}
|
||||
return updated_config
|
||||
|
||||
def _process_chat_messages(
|
||||
self, chat_message: str | Tuple | List | Dict | None
|
||||
) -> str | Dict | None:
|
||||
if chat_message is None:
|
||||
return None
|
||||
elif isinstance(chat_message, (tuple, list)):
|
||||
mime_type = processing_utils.get_mimetype(chat_message[0])
|
||||
return {
|
||||
"name": chat_message[0],
|
||||
"mime_type": mime_type,
|
||||
"alt_text": chat_message[1] if len(chat_message) > 1 else None,
|
||||
"data": None, # These last two fields are filled in by the frontend
|
||||
"is_file": True,
|
||||
}
|
||||
elif isinstance(
|
||||
chat_message, dict
|
||||
): # This happens for previously processed messages
|
||||
return chat_message
|
||||
elif isinstance(chat_message, str):
|
||||
#return self.md.render(chat_message)
|
||||
return str(self.md.convert(chat_message))
|
||||
else:
|
||||
raise ValueError(f"Invalid message for Chatbot component: {chat_message}")
|
||||
|
||||
def postprocess(
|
||||
self,
|
||||
y: List[
|
||||
Tuple[str | Tuple | List | Dict | None, str | Tuple | List | Dict | None]
|
||||
],
|
||||
) -> List[Tuple[str | Dict | None, str | Dict | None]]:
|
||||
"""
|
||||
Parameters:
|
||||
y: List of tuples representing the message and response pairs. Each message and response should be a string, which may be in Markdown format. It can also be a tuple whose first element is a string filepath or URL to an image/video/audio, and second (optional) element is the alt text, in which case the media file is displayed. It can also be None, in which case that message is not displayed.
|
||||
Returns:
|
||||
List of tuples representing the message and response. Each message and response will be a string of HTML, or a dictionary with media information.
|
||||
"""
|
||||
if y is None:
|
||||
return []
|
||||
processed_messages = []
|
||||
for message_pair in y:
|
||||
assert isinstance(
|
||||
message_pair, (tuple, list)
|
||||
), f"Expected a list of lists or list of tuples. Received: {message_pair}"
|
||||
assert (
|
||||
len(message_pair) == 2
|
||||
), f"Expected a list of lists of length 2 or list of tuples of length 2. Received: {message_pair}"
|
||||
processed_messages.append(
|
||||
(
|
||||
#self._process_chat_messages(message_pair[0]),
|
||||
'<pre style="font-family: var(--font)">' +
|
||||
message_pair[0] + "</pre>",
|
||||
self._process_chat_messages(message_pair[1]),
|
||||
)
|
||||
)
|
||||
return processed_messages
|
||||
|
||||
def style(self, height: int | None = None, **kwargs):
|
||||
"""
|
||||
This method can be used to change the appearance of the Chatbot component.
|
||||
"""
|
||||
if height is not None:
|
||||
self._style["height"] = height
|
||||
if kwargs.get("color_map") is not None:
|
||||
warnings.warn("The 'color_map' parameter has been deprecated.")
|
||||
|
||||
Component.style(
|
||||
self,
|
||||
**kwargs,
|
||||
)
|
||||
return self
|
||||
|
||||
|
||||
@@ -1,431 +0,0 @@
|
||||
import argparse
|
||||
from collections import defaultdict
|
||||
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)
|
||||
from llava.serve.gradio_patch import Chatbot as grChatbot
|
||||
from llava.serve.gradio_css import code_highlight_css
|
||||
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) + (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 '<image>' not in text:
|
||||
text = text + '\n<image>'
|
||||
text = (text, image, image_process_mode)
|
||||
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 post_process_code(code):
|
||||
sep = "\n```"
|
||||
if sep in code:
|
||||
blocks = code.split(sep)
|
||||
if len(blocks) % 2 == 1:
|
||||
for i in range(1, len(blocks), 2):
|
||||
blocks[i] = blocks[i].replace("\\_", "_")
|
||||
code = sep.join(blocks)
|
||||
return code
|
||||
|
||||
|
||||
def http_bot(state, model_selector, temperature, 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 "v1" in model_name.lower():
|
||||
template_name = "llava_v1"
|
||||
elif "mpt" in model_name.lower():
|
||||
template_name = "mpt_multimodal"
|
||||
else:
|
||||
template_name = "multimodal"
|
||||
elif "mpt" in model_name:
|
||||
template_name = "mpt_text"
|
||||
elif "koala" in model_name: # Hardcode the condition
|
||||
template_name = "bair_v1"
|
||||
elif "v1" in model_name: # vicuna v1_1/v1_2
|
||||
template_name = "vicuna_v1_1"
|
||||
else:
|
||||
template_name = "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),
|
||||
"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()
|
||||
output = post_process_code(output)
|
||||
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) [[Paper]](https://arxiv.org/abs/2304.08485) [[Code]](https://github.com/haotian-liu/LLaVA) [[Model]](https://huggingface.co/liuhaotian/LLaVA-13b-delta-v0)
|
||||
""")
|
||||
|
||||
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.
|
||||
""")
|
||||
|
||||
|
||||
css = code_highlight_css + """
|
||||
pre {
|
||||
white-space: pre-wrap; /* Since CSS 2.1 */
|
||||
white-space: -moz-pre-wrap; /* Mozilla, since 1999 */
|
||||
white-space: -pre-wrap; /* Opera 4-6 */
|
||||
white-space: -o-pre-wrap; /* Opera 7 */
|
||||
word-wrap: break-word; /* Internet Explorer 5.5+ */
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
def build_demo(embed_mode):
|
||||
textbox = gr.Textbox(show_label=False,
|
||||
placeholder="Enter text and press ENTER", visible=False).style(container=False)
|
||||
with gr.Blocks(title="LLaVA", theme=gr.themes.Base(), css=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).style(container=False)
|
||||
|
||||
imagebox = gr.Image(type="pil")
|
||||
image_process_mode = gr.Radio(
|
||||
["Crop", "Resize", "Pad"],
|
||||
value="Crop",
|
||||
label="Preprocess for non-square image")
|
||||
|
||||
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",)
|
||||
max_output_tokens = gr.Slider(minimum=0, maximum=1024, value=512, step=64, interactive=True, label="Max output tokens",)
|
||||
|
||||
with gr.Column(scale=6):
|
||||
chatbot = grChatbot(elem_id="chatbot", label="LLaVA Chatbot", visible=False).style(height=550)
|
||||
with gr.Row():
|
||||
with gr.Column(scale=8):
|
||||
textbox.render()
|
||||
with gr.Column(scale=1, min_width=60):
|
||||
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 history", 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] + btn_list).then(
|
||||
http_bot, [state, model_selector, temperature, max_output_tokens],
|
||||
[state, chatbot] + btn_list)
|
||||
clear_btn.click(clear_history, None, [state, chatbot, textbox, imagebox] + btn_list)
|
||||
|
||||
textbox.submit(add_text, [state, textbox, imagebox, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list
|
||||
).then(http_bot, [state, model_selector, temperature, max_output_tokens],
|
||||
[state, chatbot] + btn_list)
|
||||
submit_btn.click(add_text, [state, textbox, imagebox, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list
|
||||
).then(http_bot, [state, model_selector, temperature, 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)
|
||||
@@ -1,384 +0,0 @@
|
||||
"""
|
||||
A model worker executes the model.
|
||||
"""
|
||||
import argparse
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import logging
|
||||
import json
|
||||
import time
|
||||
from typing import List, Union
|
||||
import threading
|
||||
import uuid
|
||||
|
||||
from fastapi import FastAPI, Request, BackgroundTasks
|
||||
from fastapi.responses import StreamingResponse
|
||||
import requests
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
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 import *
|
||||
|
||||
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
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
def heart_beat_worker(controller):
|
||||
|
||||
while True:
|
||||
time.sleep(WORKER_HEART_BEAT_INTERVAL)
|
||||
controller.send_heart_beat()
|
||||
|
||||
|
||||
def load_model(model_path, model_name, num_gpus):
|
||||
if num_gpus == 1:
|
||||
kwargs = {}
|
||||
else:
|
||||
kwargs = {
|
||||
"device_map": "auto",
|
||||
"max_memory": {i: "13GiB" for i in range(num_gpus)},
|
||||
}
|
||||
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_path)
|
||||
if 'llava' in model_name.lower():
|
||||
if 'mpt' in model_name.lower():
|
||||
model = LlavaMPTForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, **kwargs)
|
||||
else:
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, **kwargs)
|
||||
elif 'mpt' in model_name.lower():
|
||||
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, trust_remote_code=True, **kwargs)
|
||||
else:
|
||||
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True, **kwargs)
|
||||
|
||||
image_processor = None
|
||||
|
||||
if 'llava' in model_name.lower():
|
||||
from transformers import CLIPImageProcessor, CLIPVisionModel
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.get_model().vision_tower[0]
|
||||
if vision_tower.device.type == 'meta':
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower.config._name_or_path, torch_dtype=torch.float16, low_cpu_mem_usage=True).cuda()
|
||||
model.get_model().vision_tower[0] = vision_tower
|
||||
else:
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
if num_gpus == 1:
|
||||
model.cuda()
|
||||
|
||||
if hasattr(model.config, "max_sequence_length"):
|
||||
context_len = model.config.max_sequence_length
|
||||
else:
|
||||
context_len = 2048
|
||||
|
||||
return tokenizer, model, image_processor, context_len
|
||||
|
||||
|
||||
class ModelWorker:
|
||||
def __init__(self, controller_addr, worker_addr,
|
||||
worker_id, no_register,
|
||||
model_path, model_name,
|
||||
keep_aspect_ratio,
|
||||
num_gpus):
|
||||
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.keep_aspect_ratio = keep_aspect_ratio
|
||||
self.tokenizer, self.model, self.image_processor, self.context_len = load_model(
|
||||
model_path, self.model_name, num_gpus)
|
||||
self.is_multimodal = 'llava' in model_path.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)
|
||||
if images is not None and len(images) > 0 and self.is_multimodal:
|
||||
from PIL import Image
|
||||
from io import BytesIO
|
||||
import base64
|
||||
assert type(images) is list
|
||||
if len(images) > 0:
|
||||
# assert len(images) == 1, "Only support one image for now"
|
||||
images = [Image.open(BytesIO(base64.b64decode(image))) for image in images]
|
||||
assert len(images) == prompt.count(DEFAULT_IMAGE_TOKEN), "Number of images does not match number of <image> tokens in prompt"
|
||||
|
||||
if self.keep_aspect_ratio:
|
||||
new_images = []
|
||||
for image_idx, image in enumerate(images):
|
||||
max_hw, min_hw = max(image.size), min(image.size)
|
||||
aspect_ratio = max_hw / min_hw
|
||||
max_len, min_len = 448, 224
|
||||
shortest_edge = int(min(max_len / aspect_ratio, min_len))
|
||||
image = image_processor.preprocess(image, return_tensors='pt', do_center_crop=False, size={"shortest_edge": shortest_edge})['pixel_values'][0]
|
||||
new_images.append(image.to(self.model.device, dtype=torch.float16))
|
||||
# replace the image token with the image patch token in the prompt (each occurrence)
|
||||
cur_token_len = (image.shape[1]//14) * (image.shape[2]//14)
|
||||
replace_token = DEFAULT_IMAGE_PATCH_TOKEN * cur_token_len
|
||||
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, 1)
|
||||
images = new_images
|
||||
else:
|
||||
images = image_processor(images, return_tensors='pt')['pixel_values']
|
||||
images = images.to(self.model.device, dtype=torch.float16)
|
||||
replace_token = DEFAULT_IMAGE_PATCH_TOKEN * 256 # HACK: 256 is the max image token length hacked
|
||||
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)
|
||||
else:
|
||||
images = None
|
||||
image_args = {"images": images}
|
||||
else:
|
||||
images = None
|
||||
image_args = {}
|
||||
|
||||
l_prompt = len(prompt)
|
||||
temperature = float(params.get("temperature", 1.0))
|
||||
max_new_tokens = min(int(params.get("max_new_tokens", 256)), 1024)
|
||||
stop_str = params.get("stop", None)
|
||||
stop_idx = None
|
||||
if stop_str is not None:
|
||||
stop_idx = tokenizer(stop_str).input_ids
|
||||
if len(stop_idx) == 1:
|
||||
stop_idx = stop_idx[0]
|
||||
else:
|
||||
stop_idx = None
|
||||
|
||||
input_ids = tokenizer(prompt).input_ids
|
||||
output_ids = list(input_ids)
|
||||
pred_ids = []
|
||||
|
||||
max_src_len = self.context_len - max_new_tokens - 8
|
||||
input_ids = input_ids[-max_src_len:]
|
||||
|
||||
past_key_values = None
|
||||
for i in range(max_new_tokens):
|
||||
if i == 0:
|
||||
out = model(
|
||||
torch.as_tensor([input_ids]).cuda(),
|
||||
use_cache=True,
|
||||
**image_args)
|
||||
logits = out.logits
|
||||
past_key_values = out.past_key_values
|
||||
else:
|
||||
attention_mask = torch.ones(
|
||||
1, past_key_values[0][0].shape[-2] + 1, device="cuda")
|
||||
out = model(input_ids=torch.as_tensor([[token]], device="cuda"),
|
||||
use_cache=True,
|
||||
attention_mask=attention_mask,
|
||||
past_key_values=past_key_values)
|
||||
logits = out.logits
|
||||
past_key_values = out.past_key_values
|
||||
|
||||
last_token_logits = logits[0][-1]
|
||||
if temperature < 1e-4:
|
||||
token = int(torch.argmax(last_token_logits))
|
||||
else:
|
||||
probs = torch.softmax(last_token_logits / temperature, dim=-1)
|
||||
token = int(torch.multinomial(probs, num_samples=1))
|
||||
|
||||
output_ids.append(token)
|
||||
pred_ids.append(token)
|
||||
|
||||
if stop_idx is not None and token == stop_idx:
|
||||
stopped = True
|
||||
elif token == tokenizer.eos_token_id:
|
||||
stopped = True
|
||||
else:
|
||||
stopped = False
|
||||
|
||||
if i % args.stream_interval == 0 or i == max_new_tokens - 1 or stopped:
|
||||
cur_out = tokenizer.decode(pred_ids, skip_special_tokens=True)
|
||||
pos = cur_out.rfind(stop_str)
|
||||
if pos != -1:
|
||||
cur_out = cur_out[:pos]
|
||||
stopped = True
|
||||
output = ori_prompt + cur_out
|
||||
|
||||
ret = {
|
||||
"text": output,
|
||||
"error_code": 0,
|
||||
}
|
||||
yield json.dumps(ret).encode() + b"\0"
|
||||
|
||||
if stopped:
|
||||
break
|
||||
|
||||
if past_key_values is not None:
|
||||
del past_key_values
|
||||
|
||||
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"
|
||||
|
||||
|
||||
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-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("--keep-aspect-ratio", action="store_true")
|
||||
parser.add_argument("--num-gpus", type=int, default=1)
|
||||
parser.add_argument("--limit-model-concurrency", type=int, default=5)
|
||||
parser.add_argument("--stream-interval", type=int, default=2)
|
||||
parser.add_argument("--no-register", 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_name,
|
||||
args.keep_aspect_ratio,
|
||||
args.num_gpus)
|
||||
uvicorn.run(app, host=args.host, port=args.port, log_level="info")
|
||||
@@ -1,26 +0,0 @@
|
||||
"""
|
||||
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
|
||||
@@ -1,62 +0,0 @@
|
||||
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()
|
||||
@@ -1,102 +0,0 @@
|
||||
# Adopted from https://github.com/lm-sys/FastChat. Below is the original copyright:
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
import torch
|
||||
from torch import nn
|
||||
|
||||
import transformers
|
||||
from transformers.models.llama.modeling_llama import apply_rotary_pos_emb
|
||||
|
||||
from einops import rearrange
|
||||
|
||||
from flash_attn.flash_attn_interface import flash_attn_unpadded_qkvpacked_func
|
||||
from flash_attn.bert_padding import unpad_input, pad_input
|
||||
|
||||
def forward(
|
||||
self,
|
||||
hidden_states: torch.Tensor,
|
||||
past_key_value: Optional[Tuple[torch.Tensor]] = None,
|
||||
attention_mask: Optional[torch.Tensor] = None,
|
||||
output_attentions: bool = False,
|
||||
use_cache: bool = False,
|
||||
) -> Tuple[torch.Tensor, Optional[torch.Tensor],
|
||||
Optional[Tuple[torch.Tensor]]]:
|
||||
"""Input shape: Batch x Time x Channel
|
||||
|
||||
attention_mask: [bsz, q_len]
|
||||
"""
|
||||
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_heads, self.head_dim).transpose(1, 2)
|
||||
value_states = self.v_proj(hidden_states).view(
|
||||
bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
|
||||
# [bsz, q_len, nh, hd]
|
||||
# [bsz, nh, q_len, hd]
|
||||
|
||||
kv_seq_len = key_states.shape[-2]
|
||||
offset = 0
|
||||
if past_key_value is not None:
|
||||
offset = past_key_value[0].shape[-2]
|
||||
kv_seq_len += offset
|
||||
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,
|
||||
offset=offset)
|
||||
# [bsz, nh, t, hd]
|
||||
assert not output_attentions, "output_attentions is not supported"
|
||||
assert not use_cache, "use_cache is not supported"
|
||||
assert past_key_value is None, "past_key_value is not supported"
|
||||
|
||||
# Flash attention codes from
|
||||
# https://github.com/HazyResearch/flash-attention/blob/main/flash_attn/flash_attention.py
|
||||
|
||||
# transform the data into the format required by flash attention
|
||||
qkv = torch.stack([query_states, key_states, value_states], dim=2) # [bsz, nh, 3, q_len, hd]
|
||||
qkv = qkv.transpose(1, 3) # [bsz, q_len, 3, nh, hd]
|
||||
# We have disabled _prepare_decoder_attention_mask in LlamaModel
|
||||
# the attention_mask should be the same as the key_padding_mask
|
||||
key_padding_mask = attention_mask
|
||||
|
||||
|
||||
if key_padding_mask is None:
|
||||
qkv = rearrange(qkv, 'b s ... -> (b s) ...')
|
||||
max_s = q_len
|
||||
cu_q_lens = torch.arange(0, (bsz + 1) * q_len, step=q_len, dtype=torch.int32,
|
||||
device=qkv.device)
|
||||
output = flash_attn_unpadded_qkvpacked_func(
|
||||
qkv, cu_q_lens, max_s, 0.0,
|
||||
softmax_scale=None, causal=True
|
||||
)
|
||||
output = rearrange(output, '(b s) ... -> b s ...', b=bsz)
|
||||
else:
|
||||
nheads = qkv.shape[-2]
|
||||
x = rearrange(qkv, 'b s three h d -> b s (three h d)')
|
||||
x_unpad, indices, cu_q_lens, max_s = unpad_input(x, key_padding_mask)
|
||||
x_unpad = rearrange(x_unpad, 'nnz (three h d) -> nnz three h d', three=3, h=nheads)
|
||||
output_unpad = flash_attn_unpadded_qkvpacked_func(
|
||||
x_unpad, cu_q_lens, max_s, 0.0,
|
||||
softmax_scale=None, causal=True
|
||||
)
|
||||
output = rearrange(pad_input(rearrange(output_unpad, 'nnz h d -> nnz (h d)'),
|
||||
indices, bsz, q_len),
|
||||
'b s (h d) -> b s h d', h=nheads)
|
||||
return self.o_proj(rearrange(output,
|
||||
'b s h d -> b s (h d)')), None, None
|
||||
|
||||
|
||||
# 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():
|
||||
transformers.models.llama.modeling_llama.LlamaModel._prepare_decoder_attention_mask = _prepare_decoder_attention_mask
|
||||
transformers.models.llama.modeling_llama.LlamaAttention.forward = forward
|
||||
@@ -1,49 +0,0 @@
|
||||
import os
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
from transformers import Trainer
|
||||
from typing import Dict, Optional, Sequence
|
||||
|
||||
|
||||
def unwrap_model(model: nn.Module) -> nn.Module:
|
||||
"""
|
||||
Recursively unwraps a model from potential containers (as used in distributed training).
|
||||
|
||||
Args:
|
||||
model (`torch.nn.Module`): The model to unwrap.
|
||||
"""
|
||||
# since there could be multiple levels of wrapping, unwrap recursively
|
||||
if hasattr(model, "module"):
|
||||
return unwrap_model(model.module)
|
||||
else:
|
||||
return model
|
||||
|
||||
|
||||
class LLaVATrainer(Trainer):
|
||||
|
||||
def _save(self, output_dir: Optional[str] = None, state_dict=None):
|
||||
if getattr(self.args, 'tune_mm_mlp_adapter', False):
|
||||
# Save the model
|
||||
_state_dict = state_dict
|
||||
if _state_dict is None:
|
||||
# Only save the model itself if we are using distributed training
|
||||
model_to_save = unwrap_model(self.model)
|
||||
_state_dict = model_to_save.state_dict()
|
||||
|
||||
weight_to_save = {}
|
||||
keys_to_match = ['mm_projector', 'embed_tokens', 'embed_in']
|
||||
for k, v in _state_dict.items():
|
||||
if any(key_match in k for key_match in keys_to_match):
|
||||
weight_to_save[k] = v
|
||||
|
||||
current_folder = output_dir.split('/')[-1]
|
||||
parent_folder = os.path.dirname(output_dir)
|
||||
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'))
|
||||
|
||||
super(LLaVATrainer, self)._save(output_dir, state_dict)
|
||||
@@ -1,671 +0,0 @@
|
||||
# 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
|
||||
from dataclasses import dataclass, field
|
||||
import json
|
||||
import logging
|
||||
import pathlib
|
||||
from typing import Dict, Optional, Sequence
|
||||
|
||||
import torch
|
||||
|
||||
import transformers
|
||||
from torch.utils.data import Dataset
|
||||
from llava.train.llava_trainer import LLaVATrainer
|
||||
|
||||
from llava import conversation as conversation_lib
|
||||
from llava.model import *
|
||||
|
||||
from PIL import Image
|
||||
import torch.nn as nn
|
||||
|
||||
# TODO: import and use code from ../data/dataset.py
|
||||
|
||||
IGNORE_INDEX = -100
|
||||
DEFAULT_PAD_TOKEN = "[PAD]"
|
||||
DEFAULT_EOS_TOKEN = "</s>"
|
||||
DEFAULT_BOS_TOKEN = "</s>"
|
||||
DEFAULT_UNK_TOKEN = "<unk>"
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
@dataclass
|
||||
class ModelArguments:
|
||||
model_name_or_path: Optional[str] = field(default="facebook/opt-125m")
|
||||
version: Optional[str] = field(default="v0")
|
||||
freeze_backbone: bool = field(default=False)
|
||||
tune_mm_mlp_adapter: bool = field(default=False)
|
||||
vision_tower: Optional[str] = field(default=None)
|
||||
mm_vision_select_layer: Optional[int] = field(default=-1) # default to the last layer
|
||||
pretrain_mm_mlp_adapter: Optional[str] = field(default=None)
|
||||
mm_use_im_start_end: bool = field(default=False)
|
||||
|
||||
|
||||
@dataclass
|
||||
class DataArguments:
|
||||
data_path: str = field(default=None,
|
||||
metadata={"help": "Path to the training data."})
|
||||
lazy_preprocess: bool = False
|
||||
is_multimodal: bool = False
|
||||
sep_image_conv_front: bool = False
|
||||
image_token_len: int = 0
|
||||
image_folder: Optional[str] = field(default=None)
|
||||
image_aspect_ratio: str = 'square'
|
||||
|
||||
|
||||
@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)
|
||||
force_fsdp: bool = field(default=False)
|
||||
model_max_length: int = field(
|
||||
default=512,
|
||||
metadata={
|
||||
"help":
|
||||
"Maximum sequence length. Sequences will be right padded (and possibly truncated)."
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def safe_save_model_for_hf_trainer(trainer: transformers.Trainer,
|
||||
output_dir: str):
|
||||
"""Collects the state dict and dump to disk."""
|
||||
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],
|
||||
multimodal_cfg: dict,
|
||||
cur_token_len: int,
|
||||
) -> Dict:
|
||||
is_multimodal = multimodal_cfg['is_multimodal']
|
||||
# image_token_len = multimodal_cfg['image_token_len']
|
||||
image_token_len = cur_token_len
|
||||
if not is_multimodal:
|
||||
return sources
|
||||
|
||||
for source in sources:
|
||||
if multimodal_cfg['sep_image_conv_front']:
|
||||
assert DEFAULT_IMAGE_TOKEN in source[0]['value']
|
||||
source[0]['value'] = source[0]['value'].replace(DEFAULT_IMAGE_TOKEN, '').strip()
|
||||
source[0]['value'] = DEFAULT_IMAGE_TOKEN + conversation_lib.default_conversation.sep + conversation_lib.default_conversation.roles[0] + ": " + source[0]['value']
|
||||
for sentence in source:
|
||||
replace_token = DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
if multimodal_cfg['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_v1(
|
||||
sources,
|
||||
tokenizer: transformers.PreTrainedTokenizer,
|
||||
) -> 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
|
||||
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
|
||||
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_mpt(
|
||||
sources,
|
||||
tokenizer: transformers.PreTrainedTokenizer,
|
||||
) -> 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
|
||||
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 = 0
|
||||
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
|
||||
round_len = len(tokenizer(rou).input_ids) + len(tokenizer(conv.sep).input_ids)
|
||||
instruction_len = len(tokenizer(parts[0]).input_ids)
|
||||
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(
|
||||
sources: Sequence[str],
|
||||
tokenizer: transformers.PreTrainedTokenizer,
|
||||
) -> 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.version == "v1":
|
||||
return preprocess_v1(sources, tokenizer)
|
||||
if conversation_lib.default_conversation.version == "mpt":
|
||||
return preprocess_mpt(sources, tokenizer)
|
||||
# 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
|
||||
conversations_tokenized = _tokenize_fn(conversations, tokenizer)
|
||||
input_ids = conversations_tokenized["input_ids"]
|
||||
targets = copy.deepcopy(input_ids)
|
||||
for target, source in zip(targets, sources):
|
||||
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 SupervisedDataset(Dataset):
|
||||
"""Dataset for supervised fine-tuning."""
|
||||
|
||||
def __init__(self, data_path: str,
|
||||
tokenizer: transformers.PreTrainedTokenizer):
|
||||
super(SupervisedDataset, self).__init__()
|
||||
logging.warning("Loading data...")
|
||||
list_data_dict = json.load(open(data_path, "r"))
|
||||
|
||||
logging.warning("Formatting inputs...")
|
||||
sources = [example["conversations"] for example in list_data_dict]
|
||||
data_dict = preprocess(sources, tokenizer)
|
||||
|
||||
self.input_ids = data_dict["input_ids"]
|
||||
self.labels = data_dict["labels"]
|
||||
|
||||
def __len__(self):
|
||||
return len(self.input_ids)
|
||||
|
||||
def __getitem__(self, i) -> Dict[str, torch.Tensor]:
|
||||
return dict(input_ids=self.input_ids[i], labels=self.labels[i])
|
||||
|
||||
|
||||
class LazySupervisedDataset(Dataset):
|
||||
"""Dataset for supervised fine-tuning."""
|
||||
|
||||
def __init__(self, data_path: str,
|
||||
tokenizer: transformers.PreTrainedTokenizer,
|
||||
multimodal_cfg: dict):
|
||||
super(LazySupervisedDataset, self).__init__()
|
||||
logging.warning("Loading data...")
|
||||
list_data_dict = json.load(open(data_path, "r"))
|
||||
|
||||
logging.warning("Formatting inputs...Skip in lazy mode")
|
||||
self.tokenizer = tokenizer
|
||||
self.list_data_dict = list_data_dict
|
||||
self.multimodal_cfg = multimodal_cfg
|
||||
|
||||
def __len__(self):
|
||||
return len(self.list_data_dict)
|
||||
|
||||
def __getitem__(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']
|
||||
image_folder = self.multimodal_cfg['image_folder']
|
||||
processor = self.multimodal_cfg['image_processor']
|
||||
image = Image.open(os.path.join(image_folder, image_file)).convert('RGB')
|
||||
if self.multimodal_cfg['image_aspect_ratio'] == 'keep':
|
||||
max_hw, min_hw = max(image.size), min(image.size)
|
||||
aspect_ratio = max_hw / min_hw
|
||||
max_len, min_len = 448, 224
|
||||
shortest_edge = int(min(max_len / aspect_ratio, min_len))
|
||||
image = processor.preprocess(image, return_tensors='pt', do_center_crop=False, size={"shortest_edge": shortest_edge})['pixel_values'][0]
|
||||
elif self.multimodal_cfg['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]
|
||||
cur_token_len = (image.shape[1]//14) * (image.shape[2]//14) # FIXME: 14 is hardcoded patch size
|
||||
sources = preprocess_multimodal(
|
||||
copy.deepcopy([e["conversations"] for e in sources]),
|
||||
self.multimodal_cfg, cur_token_len)
|
||||
else:
|
||||
sources = copy.deepcopy([e["conversations"] for e in sources])
|
||||
data_dict = preprocess(
|
||||
sources,
|
||||
self.tokenizer)
|
||||
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 self.multimodal_cfg['is_multimodal']:
|
||||
# image does not exist in the data, but the model is multimodal
|
||||
crop_size = self.multimodal_cfg['image_processor'].crop_size
|
||||
data_dict['image'] = torch.zeros(3, crop_size['height'], crop_size['width'])
|
||||
return data_dict
|
||||
|
||||
|
||||
@dataclass
|
||||
class DataCollatorForSupervisedDataset(object):
|
||||
"""Collate examples for supervised fine-tuning."""
|
||||
|
||||
tokenizer: transformers.PreTrainedTokenizer
|
||||
|
||||
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 = 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)
|
||||
batch = dict(
|
||||
input_ids=input_ids,
|
||||
labels=labels,
|
||||
attention_mask=input_ids.ne(self.tokenizer.pad_token_id),
|
||||
)
|
||||
|
||||
if 'image' in instances[0]:
|
||||
images = [instance['image'] for instance in instances]
|
||||
if all(x is not None and x.shape == images[0].shape for x in images):
|
||||
batch['images'] = torch.stack(images)
|
||||
else:
|
||||
batch['images'] = images
|
||||
|
||||
return batch
|
||||
|
||||
|
||||
def make_supervised_data_module(tokenizer: transformers.PreTrainedTokenizer,
|
||||
data_args) -> Dict:
|
||||
"""Make dataset and collator for supervised fine-tuning."""
|
||||
dataset_cls = (LazySupervisedDataset
|
||||
if data_args.lazy_preprocess else SupervisedDataset)
|
||||
train_dataset = dataset_cls(tokenizer=tokenizer,
|
||||
data_path=data_args.data_path,
|
||||
multimodal_cfg=dict(
|
||||
is_multimodal=data_args.is_multimodal,
|
||||
sep_image_conv_front=data_args.sep_image_conv_front,
|
||||
image_token_len=data_args.image_token_len,
|
||||
image_folder=data_args.image_folder,
|
||||
image_aspect_ratio=data_args.image_aspect_ratio,
|
||||
use_im_start_end=getattr(data_args, 'mm_use_im_start_end', False),
|
||||
image_processor=getattr(data_args, 'image_processor', None)))
|
||||
data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)
|
||||
return dict(train_dataset=train_dataset,
|
||||
eval_dataset=None,
|
||||
data_collator=data_collator)
|
||||
|
||||
|
||||
def train():
|
||||
parser = transformers.HfArgumentParser(
|
||||
(ModelArguments, DataArguments, TrainingArguments))
|
||||
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
|
||||
|
||||
if model_args.vision_tower is not None:
|
||||
if 'mpt' in model_args.model_name_or_path:
|
||||
model = LlavaMPTForCausalLM.from_pretrained(
|
||||
model_args.model_name_or_path,
|
||||
cache_dir=training_args.cache_dir,
|
||||
)
|
||||
else:
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(
|
||||
model_args.model_name_or_path,
|
||||
cache_dir=training_args.cache_dir,
|
||||
)
|
||||
else:
|
||||
model = transformers.LlamaForCausalLM.from_pretrained(
|
||||
model_args.model_name_or_path,
|
||||
cache_dir=training_args.cache_dir,
|
||||
)
|
||||
model.config.use_cache = False
|
||||
|
||||
if model_args.freeze_backbone:
|
||||
model.model.requires_grad_(False)
|
||||
|
||||
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"
|
||||
)
|
||||
else:
|
||||
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,
|
||||
)
|
||||
|
||||
if model_args.version == "v0":
|
||||
if tokenizer.pad_token is None:
|
||||
smart_tokenizer_and_embedding_resize(
|
||||
special_tokens_dict=dict(pad_token=DEFAULT_PAD_TOKEN),
|
||||
tokenizer=tokenizer,
|
||||
model=model,
|
||||
)
|
||||
if "llama" in model_args.model_name_or_path:
|
||||
tokenizer.add_special_tokens({
|
||||
"eos_token": DEFAULT_EOS_TOKEN,
|
||||
"bos_token": DEFAULT_BOS_TOKEN,
|
||||
"unk_token": DEFAULT_UNK_TOKEN,
|
||||
})
|
||||
else:
|
||||
tokenizer.pad_token = tokenizer.unk_token
|
||||
if "mpt" in model_args.model_name_or_path:
|
||||
conversation_lib.default_conversation = conversation_lib.conv_templates["mpt"]
|
||||
else:
|
||||
conversation_lib.default_conversation = conversation_lib.conv_templates["vicuna_v1_1"]
|
||||
|
||||
if model_args.vision_tower is not None:
|
||||
model_vision_dict = model.get_model().initialize_vision_modules(
|
||||
vision_tower=model_args.vision_tower,
|
||||
mm_vision_select_layer=model_args.mm_vision_select_layer,
|
||||
pretrain_mm_mlp_adapter=model_args.pretrain_mm_mlp_adapter
|
||||
)
|
||||
dtype = torch.float32
|
||||
if training_args.fp16:
|
||||
dtype = torch.float16
|
||||
if training_args.bf16:
|
||||
dtype = torch.bfloat16
|
||||
model.get_model().vision_tower[0].to(dtype=dtype, device=training_args.device)
|
||||
vision_config = model_vision_dict['vision_config']
|
||||
|
||||
data_args.image_token_len = model_vision_dict['image_token_len']
|
||||
data_args.image_processor = model_vision_dict['image_processor']
|
||||
data_args.is_multimodal = True
|
||||
|
||||
model.config.tune_mm_mlp_adapter = training_args.tune_mm_mlp_adapter = model_args.tune_mm_mlp_adapter
|
||||
if model_args.tune_mm_mlp_adapter:
|
||||
model.requires_grad_(False)
|
||||
for p in model.get_model().mm_projector.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.mm_use_im_start_end = data_args.mm_use_im_start_end = model_args.mm_use_im_start_end
|
||||
vision_config.use_im_start_end = training_args.use_im_start_end = model_args.mm_use_im_start_end
|
||||
model.config.sep_image_conv_front = data_args.sep_image_conv_front
|
||||
model.initialize_vision_tokenizer(mm_use_im_start_end=model_args.mm_use_im_start_end, tokenizer=tokenizer, device=training_args.device,
|
||||
tune_mm_mlp_adapter=model_args.tune_mm_mlp_adapter, pretrain_mm_mlp_adapter=model_args.pretrain_mm_mlp_adapter)
|
||||
|
||||
params_no_grad = [n for n, p in model.named_parameters() if not p.requires_grad]
|
||||
if len(params_no_grad) > 0:
|
||||
if training_args.fsdp is not None and len(training_args.fsdp) > 0:
|
||||
if len(params_no_grad) < 10:
|
||||
print('[WARNING] Attempting to use FSDP while {} parameters do not require gradients: {}'. format(len(params_no_grad), params_no_grad))
|
||||
else:
|
||||
print('[WARNING] Attempting to use FSDP while {} parameters do not require gradients: {}...(omitted)'. format(len(params_no_grad), ', '.join(params_no_grad[:10])))
|
||||
print("[WARNING] Attempting to use FSDP with partially frozen paramters, this is experimental.")
|
||||
print("[WARNING] As of 4/30/23, this feature requires PyTorch-nightly build. See here for details: https://github.com/haotian-liu/LLaVA#experimental-use-fsdp-to-save-memory-in-pretraining")
|
||||
|
||||
from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
|
||||
def patch_FSDP_use_orig_params(func):
|
||||
def wrap_func(*args, **kwargs):
|
||||
use_orig_params = kwargs.pop('use_orig_params', True)
|
||||
return func(*args, **kwargs, use_orig_params=use_orig_params)
|
||||
return wrap_func
|
||||
|
||||
FSDP.__init__ = patch_FSDP_use_orig_params(FSDP.__init__)
|
||||
|
||||
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()
|
||||
safe_save_model_for_hf_trainer(trainer=trainer,
|
||||
output_dir=training_args.output_dir)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
train()
|
||||
@@ -1,13 +0,0 @@
|
||||
# Adopted from https://github.com/lm-sys/FastChat. Below is the original copyright:
|
||||
# Adopted from tatsu-lab@stanford_alpaca. Below is the original copyright:
|
||||
# Make it more memory efficient by monkey patching the LLaMA model with FlashAttn.
|
||||
|
||||
# Need to call this before importing transformers.
|
||||
from llava.train.llama_flash_attn_monkey_patch import replace_llama_attn_with_flash_attn
|
||||
|
||||
replace_llama_attn_with_flash_attn()
|
||||
|
||||
from llava.train.train import train
|
||||
|
||||
if __name__ == "__main__":
|
||||
train()
|
||||
@@ -1,126 +0,0 @@
|
||||
import datetime
|
||||
import logging
|
||||
import logging.handlers
|
||||
import os
|
||||
import sys
|
||||
|
||||
import requests
|
||||
|
||||
from llava.constants import LOGDIR
|
||||
|
||||
server_error_msg = "**NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE.**"
|
||||
moderation_msg = "YOUR INPUT VIOLATES OUR CONTENT MODERATION GUIDELINES. PLEASE TRY AGAIN."
|
||||
|
||||
handler = None
|
||||
|
||||
|
||||
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:
|
||||
flagged = False
|
||||
except KeyError as 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()})"
|
||||
@@ -1 +0,0 @@
|
||||
from .model import LlavaLlamaForCausalLM
|
||||
@@ -1,4 +0,0 @@
|
||||
CONTROLLER_HEART_BEAT_EXPIRATION = 30
|
||||
WORKER_HEART_BEAT_INTERVAL = 15
|
||||
|
||||
LOGDIR = "."
|
||||
@@ -1,368 +0,0 @@
|
||||
import dataclasses
|
||||
from enum import auto, Enum
|
||||
from typing import List, Tuple
|
||||
|
||||
|
||||
class SeparatorStyle(Enum):
|
||||
"""Different separator style."""
|
||||
SINGLE = auto()
|
||||
TWO = auto()
|
||||
MPT = auto()
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class Conversation:
|
||||
"""A class that keeps all conversation history."""
|
||||
system: str
|
||||
roles: List[str]
|
||||
messages: List[List[str]]
|
||||
offset: int
|
||||
sep_style: SeparatorStyle = SeparatorStyle.SINGLE
|
||||
sep: str = "###"
|
||||
sep2: str = None
|
||||
version: str = "Unknown"
|
||||
|
||||
skip_next: bool = False
|
||||
|
||||
def get_prompt(self):
|
||||
if self.sep_style == SeparatorStyle.SINGLE:
|
||||
ret = self.system + self.sep
|
||||
for role, message in self.messages:
|
||||
if message:
|
||||
if type(message) is tuple:
|
||||
message, _, _ = message
|
||||
ret += role + ": " + message + self.sep
|
||||
else:
|
||||
ret += role + ":"
|
||||
return ret
|
||||
elif self.sep_style == SeparatorStyle.TWO:
|
||||
seps = [self.sep, self.sep2]
|
||||
ret = self.system + seps[0]
|
||||
for i, (role, message) in enumerate(self.messages):
|
||||
if message:
|
||||
if type(message) is tuple:
|
||||
message, _, _ = message
|
||||
ret += role + ": " + message + seps[i % 2]
|
||||
else:
|
||||
ret += role + ":"
|
||||
return ret
|
||||
if self.sep_style == SeparatorStyle.MPT:
|
||||
ret = self.system + self.sep
|
||||
for role, message in self.messages:
|
||||
if message:
|
||||
if type(message) is tuple:
|
||||
message, _, _ = message
|
||||
ret += role + message + self.sep
|
||||
else:
|
||||
ret += role
|
||||
return ret
|
||||
else:
|
||||
raise ValueError(f"Invalid style: {self.sep_style}")
|
||||
|
||||
def append_message(self, role, message):
|
||||
self.messages.append([role, message])
|
||||
|
||||
def get_images(self, return_pil=False):
|
||||
images = []
|
||||
for i, (role, msg) in enumerate(self.messages[self.offset:]):
|
||||
if i % 2 == 0:
|
||||
if type(msg) is tuple:
|
||||
import base64
|
||||
from io import BytesIO
|
||||
from PIL import Image
|
||||
msg, image, image_process_mode = msg
|
||||
if image_process_mode == "Pad":
|
||||
def expand2square(pil_img, background_color=(122, 116, 104)):
|
||||
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)
|
||||
elif image_process_mode == "Crop":
|
||||
pass
|
||||
elif image_process_mode == "Resize":
|
||||
image = image.resize((224, 224))
|
||||
else:
|
||||
raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
|
||||
max_hw, min_hw = max(image.size), min(image.size)
|
||||
aspect_ratio = max_hw / min_hw
|
||||
max_len, min_len = 800, 400
|
||||
shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
|
||||
longest_edge = int(shortest_edge * aspect_ratio)
|
||||
W, H = image.size
|
||||
if H > W:
|
||||
H, W = longest_edge, shortest_edge
|
||||
else:
|
||||
H, W = shortest_edge, longest_edge
|
||||
image = image.resize((W, H))
|
||||
if return_pil:
|
||||
images.append(image)
|
||||
else:
|
||||
buffered = BytesIO()
|
||||
image.save(buffered, format="JPEG")
|
||||
img_b64_str = base64.b64encode(buffered.getvalue()).decode()
|
||||
images.append(img_b64_str)
|
||||
return images
|
||||
|
||||
def to_gradio_chatbot(self):
|
||||
ret = []
|
||||
for i, (role, msg) in enumerate(self.messages[self.offset:]):
|
||||
if i % 2 == 0:
|
||||
if type(msg) is tuple:
|
||||
import base64
|
||||
from io import BytesIO
|
||||
msg, image, image_process_mode = msg
|
||||
max_hw, min_hw = max(image.size), min(image.size)
|
||||
aspect_ratio = max_hw / min_hw
|
||||
max_len, min_len = 800, 400
|
||||
shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
|
||||
longest_edge = int(shortest_edge * aspect_ratio)
|
||||
W, H = image.size
|
||||
if H > W:
|
||||
H, W = longest_edge, shortest_edge
|
||||
else:
|
||||
H, W = shortest_edge, longest_edge
|
||||
image = image.resize((W, H))
|
||||
# image = image.resize((224, 224))
|
||||
buffered = BytesIO()
|
||||
image.save(buffered, format="JPEG")
|
||||
img_b64_str = base64.b64encode(buffered.getvalue()).decode()
|
||||
img_str = f'<img src="data:image/png;base64,{img_b64_str}" alt="user upload image" />'
|
||||
msg = msg.replace('<image>', img_str)
|
||||
ret.append([msg, None])
|
||||
else:
|
||||
ret[-1][-1] = msg
|
||||
return ret
|
||||
|
||||
def copy(self):
|
||||
return Conversation(
|
||||
system=self.system,
|
||||
roles=self.roles,
|
||||
messages=[[x, y] for x, y in self.messages],
|
||||
offset=self.offset,
|
||||
sep_style=self.sep_style,
|
||||
sep=self.sep,
|
||||
sep2=self.sep2)
|
||||
|
||||
def dict(self):
|
||||
if len(self.get_images()) > 0:
|
||||
return {
|
||||
"system": self.system,
|
||||
"roles": self.roles,
|
||||
"messages": [[x, y[0] if type(y) is tuple else y] for x, y in self.messages],
|
||||
"offset": self.offset,
|
||||
"sep": self.sep,
|
||||
"sep2": self.sep2,
|
||||
}
|
||||
return {
|
||||
"system": self.system,
|
||||
"roles": self.roles,
|
||||
"messages": self.messages,
|
||||
"offset": self.offset,
|
||||
"sep": self.sep,
|
||||
"sep2": self.sep2,
|
||||
}
|
||||
|
||||
|
||||
conv_v1 = Conversation(
|
||||
system="A chat between a curious human and an artificial intelligence assistant. "
|
||||
"The assistant gives helpful, detailed, and polite answers to the human's questions.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Give three tips for staying healthy."),
|
||||
("Assistant",
|
||||
"Sure, here are three tips for staying healthy:\n"
|
||||
"1. Exercise regularly: Regular physical activity can help improve your overall health and wellbeing. "
|
||||
"It can also help reduce your risk of chronic conditions such as obesity, diabetes, heart disease, "
|
||||
"and certain cancers. Aim for at least 150 minutes of moderate-intensity aerobic exercise or "
|
||||
"75 minutes of vigorous-intensity aerobic exercise per week, along with muscle-strengthening "
|
||||
"activities at least two days per week.\n"
|
||||
"2. Eat a balanced diet: Eating a balanced diet that is rich in fruits, "
|
||||
"vegetables, whole grains, lean proteins, and healthy fats can help support "
|
||||
"your overall health. Try to limit your intake of processed and high-sugar foods, "
|
||||
"and aim to drink plenty of water throughout the day.\n"
|
||||
"3. Get enough sleep: Getting enough quality sleep is essential for your physical "
|
||||
"and mental health. Adults should aim for seven to nine hours of sleep per night. "
|
||||
"Establish a regular sleep schedule and try to create a relaxing bedtime routine to "
|
||||
"help improve the quality of your sleep.")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
conv_v1_2 = Conversation(
|
||||
system="A chat between a curious human and an artificial intelligence assistant. "
|
||||
"The assistant gives helpful, detailed, and polite answers to the human's questions.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "What are the key differences between renewable and non-renewable energy sources?"),
|
||||
("Assistant",
|
||||
"Renewable energy sources are those that can be replenished naturally in a relatively "
|
||||
"short amount of time, such as solar, wind, hydro, geothermal, and biomass. "
|
||||
"Non-renewable energy sources, on the other hand, are finite and will eventually be "
|
||||
"depleted, such as coal, oil, and natural gas. Here are some key differences between "
|
||||
"renewable and non-renewable energy sources:\n"
|
||||
"1. Availability: Renewable energy sources are virtually inexhaustible, while non-renewable "
|
||||
"energy sources are finite and will eventually run out.\n"
|
||||
"2. Environmental impact: Renewable energy sources have a much lower environmental impact "
|
||||
"than non-renewable sources, which can lead to air and water pollution, greenhouse gas emissions, "
|
||||
"and other negative effects.\n"
|
||||
"3. Cost: Renewable energy sources can be more expensive to initially set up, but they typically "
|
||||
"have lower operational costs than non-renewable sources.\n"
|
||||
"4. Reliability: Renewable energy sources are often more reliable and can be used in more remote "
|
||||
"locations than non-renewable sources.\n"
|
||||
"5. Flexibility: Renewable energy sources are often more flexible and can be adapted to different "
|
||||
"situations and needs, while non-renewable sources are more rigid and inflexible.\n"
|
||||
"6. Sustainability: Renewable energy sources are more sustainable over the long term, while "
|
||||
"non-renewable sources are not, and their depletion can lead to economic and social instability.\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
conv_vicuna_v1_1 = Conversation(
|
||||
system="A chat between a curious user and an artificial intelligence assistant. "
|
||||
"The assistant gives helpful, detailed, and polite answers to the user's questions.",
|
||||
roles=("USER", "ASSISTANT"),
|
||||
version="v1",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.TWO,
|
||||
sep=" ",
|
||||
sep2="</s>",
|
||||
)
|
||||
|
||||
conv_mpt = Conversation(
|
||||
system="""<|im_start|>system
|
||||
- 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.
|
||||
- You should follow the instructions carefully and explain your answers in detail.""",
|
||||
roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
|
||||
version="mpt",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.MPT,
|
||||
sep="<|im_end|>",
|
||||
)
|
||||
|
||||
conv_mpt_text = Conversation(
|
||||
system="""<|im_start|>system
|
||||
- You are a helpful assistant chatbot trained by MosaicML.
|
||||
- You answer questions.
|
||||
- You are excited to be able to help the user, but will refuse to do anything that could be considered harmful to the user.
|
||||
- You are more than just an information source, you are also able to write poetry, short stories, and make jokes.""",
|
||||
roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
|
||||
version="mpt",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.MPT,
|
||||
sep="<|im_end|>",
|
||||
)
|
||||
|
||||
conv_bair_v1 = Conversation(
|
||||
system="BEGINNING OF CONVERSATION:",
|
||||
roles=("USER", "GPT"),
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.TWO,
|
||||
sep=" ",
|
||||
sep2="</s>",
|
||||
)
|
||||
|
||||
simple_conv = Conversation(
|
||||
system="You are LLaVA, a large language model trained by UW Madison WAIV Lab, based on LLaMA architecture."
|
||||
"You are designed to assist human with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Hi!"),
|
||||
("Assistant", "Hi there! How can I help you today?\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
simple_conv_multimodal = Conversation(
|
||||
system="You are LLaVA, a large language and vision assistant trained by UW Madison WAIV Lab."
|
||||
"You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully and explain your answers in detail.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Hi!"),
|
||||
("Assistant", "Hi there! How can I help you today?\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
simple_conv_mpt_multimodal = Conversation(
|
||||
system="""<|im_start|>system
|
||||
- You are LLaVA, a large language and vision assistant trained by UW Madison WAIV Lab.
|
||||
- You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language.
|
||||
- You should follow the instructions carefully and explain your answers in detail.""",
|
||||
roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
|
||||
version="mpt",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.MPT,
|
||||
sep="<|im_end|>",
|
||||
)
|
||||
|
||||
simple_conv_legacy = Conversation(
|
||||
system="You are LLaVA, a large language model trained by UW Madison WAIV Lab."
|
||||
"You are designed to assist human with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully.",
|
||||
roles=("Human", "Assistant"),
|
||||
messages=(
|
||||
("Human", "Hi!\n\n### Response:"),
|
||||
("Assistant", "Hi there! How can I help you today?\n")
|
||||
),
|
||||
offset=2,
|
||||
sep_style=SeparatorStyle.SINGLE,
|
||||
sep="###",
|
||||
)
|
||||
|
||||
conv_llava_v1 = Conversation(
|
||||
system="You are LLaVA, a large language and vision assistant trained by UW Madison WAIV Lab."
|
||||
"You are able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
|
||||
"Follow the instructions carefully and explain your answers in detail.",
|
||||
roles=("USER", "ASSISTANT"),
|
||||
version="v1",
|
||||
messages=(),
|
||||
offset=0,
|
||||
sep_style=SeparatorStyle.TWO,
|
||||
sep=" ",
|
||||
sep2="</s>",
|
||||
)
|
||||
|
||||
default_conversation = conv_v1_2
|
||||
conv_templates = {
|
||||
"default": conv_v1_2,
|
||||
"simple": simple_conv,
|
||||
"simple_legacy": simple_conv_legacy,
|
||||
"multimodal": simple_conv_multimodal,
|
||||
"mpt_multimodal": simple_conv_mpt_multimodal,
|
||||
"llava_v1": conv_llava_v1,
|
||||
|
||||
# fastchat
|
||||
"v1": conv_v1_2,
|
||||
"bair_v1": conv_bair_v1,
|
||||
"vicuna_v1_1": conv_vicuna_v1_1,
|
||||
"mpt": conv_mpt,
|
||||
"mpt_text": conv_mpt_text,
|
||||
}
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(default_conversation.get_prompt())
|
||||
@@ -1,58 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import pathlib
|
||||
|
||||
# Prompt from stanford alpaca's training script
|
||||
PROMPT_DICT = {
|
||||
"prompt_input": (
|
||||
"Below is an instruction that describes a task, paired with an input that provides further context. "
|
||||
"Write a response that appropriately completes the request.\n\n"
|
||||
"### Instruction:\n{instruction}\n\n### Input:\n{input}\n\n### Response:"
|
||||
),
|
||||
"prompt_no_input": (
|
||||
"Below is an instruction that describes a task. "
|
||||
"Write a response that appropriately completes the request.\n\n"
|
||||
"### Instruction:\n{instruction}\n\n### Response:"
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def main(args):
|
||||
data_path = pathlib.Path(args.data_path)
|
||||
with data_path.open() as f:
|
||||
data = json.load(f)
|
||||
|
||||
prompt_input, prompt_no_input = PROMPT_DICT["prompt_input"], PROMPT_DICT["prompt_no_input"]
|
||||
sources = [
|
||||
prompt_input.format_map(example) if example.get("input", "") != "" else prompt_no_input.format_map(example)
|
||||
for example in data
|
||||
]
|
||||
targets = [example['output'] for example in data]
|
||||
|
||||
new_data = []
|
||||
cnt = 1
|
||||
for s, t in zip(sources, targets):
|
||||
new_data.append({
|
||||
'id': str(cnt),
|
||||
'conversations': [
|
||||
{
|
||||
'from': 'human',
|
||||
'value': s,
|
||||
},
|
||||
{
|
||||
'from': 'gpt',
|
||||
'value': t,
|
||||
}
|
||||
]
|
||||
})
|
||||
cnt += 1
|
||||
|
||||
json.dump(new_data, open(args.output_path, 'w'), indent=2)
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--data_path', type=str, default='alpaca-data.json')
|
||||
parser.add_argument('--output_path', type=str, default='alpaca-data-conversation.json')
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
|
||||
@@ -1,195 +0,0 @@
|
||||
"""
|
||||
- Convert html to markdown with basic data cleaning.
|
||||
- Deduplication.
|
||||
|
||||
Usage:
|
||||
python3 -m fastchat.data.clean_sharegpt --in sharegpt_html.json --out sharegpt_clean.json
|
||||
"""
|
||||
import argparse
|
||||
from concurrent.futures import ProcessPoolExecutor
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from typing import Dict, Union
|
||||
|
||||
import bs4
|
||||
import markdownify # == 0.11.6
|
||||
from tqdm import tqdm
|
||||
|
||||
|
||||
div_pattern = re.compile("<div.*?>")
|
||||
span_pattern = re.compile("<span.*?>")
|
||||
code_lang_pattern = re.compile(
|
||||
"```\s*" + "(.*?)" + "(?:Copy code)+" + "(.+?)" + "\s*?```", re.DOTALL
|
||||
)
|
||||
code_lang_format = "```\g<1>\n\g<2>\n```"
|
||||
regenerate_pattern = re.compile("\d+ / \d+")
|
||||
copy_chars_pattern = re.compile("Copy\d+ chars / \d+ words")
|
||||
copy_code_pattern = re.compile("```(.*?)Copy code\s*```")
|
||||
|
||||
|
||||
def reformat_code(val: str) -> str:
|
||||
# Input code format is:
|
||||
# ```
|
||||
# $<language>Copy code$<exact_code_here>
|
||||
#
|
||||
# ```
|
||||
# This function convert it into the correct markdown format
|
||||
return re.sub(code_lang_pattern, code_lang_format, val)
|
||||
|
||||
|
||||
def html_to_markdown(val: str) -> str:
|
||||
# Remove all <div>. This is required to make intent work in code blocks.
|
||||
val = re.sub(div_pattern, "", val)
|
||||
# Remove all <span>. This is required to make underscores work in code blocks.
|
||||
val = re.sub(span_pattern, "", val)
|
||||
# Markdown to html
|
||||
val = markdownify.markdownify(val).strip()
|
||||
# Reformat code
|
||||
val = reformat_code(val)
|
||||
|
||||
# Remove noisy "[number] / [number]" at the beginning
|
||||
noise = re.search(regenerate_pattern, val)
|
||||
if noise and noise.start() == 0:
|
||||
val = val[noise.end() :]
|
||||
# Remove noisy "Copy[number] chars / [number] words"
|
||||
val = re.sub(copy_chars_pattern, "", val)
|
||||
# Remove empty code block ```\nCopy code\n```
|
||||
val = re.sub(copy_code_pattern, "", val)
|
||||
|
||||
# Strip
|
||||
val = val.replace("\n\n\n", "\n").strip()
|
||||
|
||||
return val
|
||||
|
||||
|
||||
def contain_blocked_words(val: str) -> bool:
|
||||
blocked_words = ["openai", "chatgpt"]
|
||||
for w in blocked_words:
|
||||
if w in val.lower():
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def clean_html_one_sample(sample):
|
||||
roles = ["human", "gpt"]
|
||||
|
||||
if len(sample["conversations"]) <= 1:
|
||||
return (sample, 1)
|
||||
|
||||
# Adjust the offset for cases like https://sharegpt.com/c/VyaZlh4
|
||||
if sample["conversations"][0]["from"] != "human":
|
||||
sample["conversations"] = sample["conversations"][1:]
|
||||
if len(sample["conversations"]) <= 1:
|
||||
return (sample, 1)
|
||||
|
||||
if sample["conversations"][-1]["from"] == "human":
|
||||
sample["conversations"] = sample["conversations"][:-1]
|
||||
if len(sample["conversations"]) <= 1:
|
||||
return (sample, 1)
|
||||
|
||||
for i, c in enumerate(sample["conversations"]):
|
||||
if c["from"] != roles[i % 2]:
|
||||
return (sample, 2)
|
||||
|
||||
if contain_blocked_words(c["value"]):
|
||||
return (sample, 3)
|
||||
|
||||
try:
|
||||
new_val = html_to_markdown(c["value"])
|
||||
except (bs4.builder.ParserRejectedMarkup, AssertionError):
|
||||
return (sample, 4)
|
||||
|
||||
c["value"] = new_val
|
||||
|
||||
return (sample, 0)
|
||||
|
||||
|
||||
def clean_html_all(content, begin, end):
|
||||
"""
|
||||
Clean the source html files.
|
||||
"""
|
||||
cnt_skip = 0
|
||||
cnt_blocked_words = 0
|
||||
cnt_wrong_format = 0
|
||||
cnt_parser_error = 0
|
||||
cnt_too_short = 0
|
||||
cnt_id_duplication = 0
|
||||
cnt_value_duplication = 0
|
||||
cnt_tag = 0
|
||||
|
||||
content = content[begin:end]
|
||||
processed = []
|
||||
with ProcessPoolExecutor() as executor:
|
||||
for result in tqdm(
|
||||
executor.map(clean_html_one_sample, content), total=len(content)
|
||||
):
|
||||
processed.append(result)
|
||||
|
||||
visited = {}
|
||||
new_content = []
|
||||
for sample, error_code in tqdm(processed):
|
||||
cid = sample["id"]
|
||||
skipped = True
|
||||
|
||||
if error_code != 0:
|
||||
if error_code == 1:
|
||||
print(f"id {cid} is too short")
|
||||
cnt_too_short += 1
|
||||
elif error_code == 2:
|
||||
print(f"id {cid} has a wrong format")
|
||||
cnt_wrong_format += 1
|
||||
elif error_code == 3:
|
||||
print(f"id {cid} contains blocked words")
|
||||
cnt_blocked_words += 1
|
||||
elif error_code == 4:
|
||||
print(f"id {cid} contains parser errors")
|
||||
cnt_parser_error += 1
|
||||
else:
|
||||
raise ValueError(f"Invalid error_code: {error_code}")
|
||||
elif cid in visited:
|
||||
print(f"id {cid} is an id duplication of {visited[cid]}")
|
||||
cnt_id_duplication += 1
|
||||
elif (
|
||||
sample["conversations"][1]["value"],
|
||||
len(sample["conversations"]),
|
||||
) in visited:
|
||||
key = (sample["conversations"][1]["value"], len(sample["conversations"]))
|
||||
print(f"id {cid} is a value duplication of {visited[key]}")
|
||||
cnt_value_duplication += 1
|
||||
else:
|
||||
key = (sample["conversations"][1]["value"], len(sample["conversations"]))
|
||||
visited[cid] = visited[key] = cid
|
||||
skipped = False
|
||||
|
||||
if not skipped:
|
||||
new_content.append(sample)
|
||||
else:
|
||||
cnt_skip += 1
|
||||
|
||||
print(
|
||||
f"total: {len(content)}, skip: {cnt_skip}, new: {len(new_content)}, "
|
||||
f"cnt_blocked_words: {cnt_blocked_words}, cnt_parser_error: {cnt_parser_error}, "
|
||||
f"cnt_wrong_format: {cnt_wrong_format}, "
|
||||
f"cnt_too_short: {cnt_too_short}, cnt_id_duplication: {cnt_id_duplication}, "
|
||||
f"cnt_value_duplication: {cnt_value_duplication}, "
|
||||
)
|
||||
|
||||
return new_content
|
||||
|
||||
|
||||
def main(args):
|
||||
content = json.load(open(args["in_file"], "r"))
|
||||
content = clean_html_all(content, args["begin"], args["end"])
|
||||
json.dump(content, open(args["out_file"], "w"), indent=2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, default="sharegpt_clean.json")
|
||||
parser.add_argument("--begin", type=int)
|
||||
parser.add_argument("--end", type=int)
|
||||
parser.add_argument("--debug", action="store_true")
|
||||
args = parser.parse_args()
|
||||
main(vars(args))
|
||||
@@ -1,23 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.data.inspect --in sharegpt_20230322_clean_lang_split.json
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
|
||||
import tqdm
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--begin", type=int)
|
||||
args = parser.parse_args()
|
||||
|
||||
content = json.load(open(args.in_file, "r"))
|
||||
for sample in tqdm.tqdm(content[args.begin:]):
|
||||
print(f"id: {sample['id']}")
|
||||
for conv in sample["conversations"]:
|
||||
print(conv["from"] + ": ")
|
||||
print(conv["value"])
|
||||
input()
|
||||
@@ -1,80 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.data.optional_clean --lang en --reduce-rep --in sharegpt_clean.json --out output.json
|
||||
python3 -m fastchat.data.optional_clean --skip-lang en --reduce-rep --in sharegpt_clean.json --out output.json
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import re
|
||||
|
||||
import polyglot
|
||||
from polyglot.detect import Detector
|
||||
import pycld2
|
||||
from tqdm import tqdm
|
||||
|
||||
|
||||
def skip(conv, args):
|
||||
# Remove certain languages
|
||||
if args.lang != "all" or args.skip_lang is not None:
|
||||
text = "\n".join([x["value"] for x in conv["conversations"]])
|
||||
try:
|
||||
lang_code = Detector(text).language.code
|
||||
except (pycld2.error, polyglot.detect.base.UnknownLanguage):
|
||||
lang_code = "unknown"
|
||||
|
||||
if args.lang != "all" and lang_code != args.lang:
|
||||
return True
|
||||
|
||||
if lang_code == args.skip_lang:
|
||||
return True
|
||||
|
||||
# Remove repetitive numbers
|
||||
if args.reduce_rep:
|
||||
for sentence in conv["conversations"]:
|
||||
val = sentence["value"]
|
||||
sub = re.search(r"(\d)\1{8}", val)
|
||||
if sub is not None:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, default="")
|
||||
parser.add_argument("--lang", type=str, default="all",
|
||||
choices=["all", "en"])
|
||||
parser.add_argument("--skip-lang", type=str)
|
||||
# NOTE: Be careful about reduce_rep which may remove some good data.
|
||||
# For example, addresses could have long consecutive 0's
|
||||
parser.add_argument("--reduce-rep", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
in_file = args.in_file
|
||||
out_file = args.out_file
|
||||
lang = args.lang
|
||||
skip_lang = args.skip_lang
|
||||
reduce_rep = args.reduce_rep
|
||||
assert (lang == "all" or skip_lang is None)
|
||||
|
||||
if out_file == "":
|
||||
out_file = "sharegpt_clean"
|
||||
if lang != "all":
|
||||
out_file += "_" + lang
|
||||
if skip_lang is not None:
|
||||
out_file += "_skip_" + skip_lang
|
||||
if reduce_rep:
|
||||
out_file += "_reduce_rep"
|
||||
out_file += ".json"
|
||||
|
||||
content = json.load(open(in_file, "r"))
|
||||
num_conv = len(content)
|
||||
|
||||
new_content = []
|
||||
for conv in tqdm(content):
|
||||
if not skip(conv, args):
|
||||
new_content.append(conv)
|
||||
|
||||
print(f"return {len(new_content)} out of {len(content)}, start dump ...")
|
||||
json.dump(new_content, open(out_file, "w"), indent=2)
|
||||
@@ -1,20 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 pretty_json.py --in in.json --out out.json
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, required=True)
|
||||
args = parser.parse_args()
|
||||
|
||||
with open(args.in_file, "r") as fin:
|
||||
data = json.load(fin)
|
||||
|
||||
with open(args.out_file, "w") as fout:
|
||||
json.dump(data, fout, indent=2)
|
||||
@@ -1,99 +0,0 @@
|
||||
"""
|
||||
Split long conversations based on certain max length.
|
||||
|
||||
Usage: python3 -m fastchat.data.split_long_conversation \
|
||||
--in sharegpt_clean.json \
|
||||
--out sharegpt_split.json \
|
||||
--model-name-or-path $<model-name>
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
from typing import Dict, Sequence, Optional
|
||||
|
||||
import transformers
|
||||
import tqdm
|
||||
|
||||
from llava import conversation as conversation_lib
|
||||
|
||||
DEFAULT_PAD_TOKEN = "[PAD]"
|
||||
BEGIN_SIGNAL = "### "
|
||||
END_SIGNAL = "\n"
|
||||
|
||||
|
||||
def split_sample(sample, start_idx, end_idx):
|
||||
# only ends in the bot because otherwise the last human part is useless.
|
||||
end_speaker = sample["conversations"][end_idx]["from"]
|
||||
end_idx = end_idx + 1 if end_speaker != "human" else end_idx
|
||||
return {
|
||||
"id": sample["id"] + "_" + str(start_idx),
|
||||
"conversations": sample["conversations"][start_idx:end_idx]
|
||||
}
|
||||
|
||||
|
||||
def split_contents(content, begin, end, tokenizer, max_length):
|
||||
"""
|
||||
Keep the maximum round of conversations within the max token length constraint
|
||||
"""
|
||||
content = content[begin:end]
|
||||
new_content = []
|
||||
|
||||
for sample in tqdm.tqdm(content):
|
||||
tokenized_lens = []
|
||||
|
||||
for c in sample["conversations"]:
|
||||
from_str = c["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 = (BEGIN_SIGNAL + from_str + ": " + c["value"] +
|
||||
END_SIGNAL)
|
||||
length = tokenizer(sentence, return_tensors="pt", padding="longest"
|
||||
).input_ids.ne(tokenizer.pad_token_id).sum().item()
|
||||
tokenized_lens.append(length)
|
||||
|
||||
num_tokens = 0
|
||||
start_idx = 0
|
||||
for idx, l in enumerate(tokenized_lens):
|
||||
# TODO: shall we also only starts from a specific speaker?
|
||||
if num_tokens + l > max_length:
|
||||
new_content.append(split_sample(sample, start_idx, idx))
|
||||
start_idx = idx
|
||||
num_tokens = l
|
||||
else:
|
||||
num_tokens += l
|
||||
if idx == len(tokenized_lens) - 1:
|
||||
new_content.append(split_sample(sample, start_idx, idx))
|
||||
|
||||
print(f"total: {len(content)}, new: {len(new_content)}")
|
||||
return new_content
|
||||
|
||||
|
||||
def main(args):
|
||||
content = json.load(open(args.in_file, "r"))
|
||||
tokenizer = transformers.AutoTokenizer.from_pretrained(
|
||||
args.model_name_or_path,
|
||||
model_max_length=args.max_length,
|
||||
padding_side="right",
|
||||
use_fast=False,
|
||||
)
|
||||
if tokenizer.pad_token is None:
|
||||
tokenizer.add_special_tokens(dict(pad_token=DEFAULT_PAD_TOKEN))
|
||||
content = split_contents(content, args.begin, args.end,
|
||||
tokenizer, args.max_length)
|
||||
json.dump(content, open(args.out_file, "w"), indent=2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--in-file", type=str, required=True)
|
||||
parser.add_argument("--out-file", type=str, default="sharegpt_split.json")
|
||||
parser.add_argument("--begin", type=int)
|
||||
parser.add_argument("--end", type=int)
|
||||
parser.add_argument("--model-name-or-path", type=str, required=True)
|
||||
parser.add_argument("--max-length", type=int, default=2304)
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
@@ -1,111 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
|
||||
import openai
|
||||
import tqdm
|
||||
import ray
|
||||
import time
|
||||
|
||||
@ray.remote(num_cpus=4)
|
||||
def get_eval(content: str, max_tokens: int):
|
||||
while True:
|
||||
try:
|
||||
response = openai.ChatCompletion.create(
|
||||
model='gpt-4',
|
||||
messages=[{
|
||||
'role': 'system',
|
||||
'content': 'You are a helpful and precise assistant for checking the quality of the answer.'
|
||||
}, {
|
||||
'role': 'user',
|
||||
'content': content,
|
||||
}],
|
||||
temperature=0.2, # TODO: figure out which temperature is best for evaluation
|
||||
max_tokens=max_tokens,
|
||||
)
|
||||
break
|
||||
except openai.error.RateLimitError:
|
||||
pass
|
||||
except Exception as e:
|
||||
print(e)
|
||||
time.sleep(1)
|
||||
|
||||
print('success!')
|
||||
return response['choices'][0]['message']['content']
|
||||
|
||||
|
||||
def parse_score(review):
|
||||
try:
|
||||
score_pair = review.split('\n')[0]
|
||||
score_pair = score_pair.replace(',', ' ')
|
||||
sp = score_pair.split(' ')
|
||||
if len(sp) == 2:
|
||||
return [float(sp[0]), float(sp[1])]
|
||||
else:
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
except Exception as e:
|
||||
print(e)
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
|
||||
parser.add_argument('-q', '--question')
|
||||
# parser.add_argument('-a', '--answer')
|
||||
parser.add_argument('-a', '--answer-list', nargs='+', default=[])
|
||||
parser.add_argument('-r', '--rule')
|
||||
parser.add_argument('-o', '--output')
|
||||
parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
|
||||
args = parser.parse_args()
|
||||
|
||||
ray.init()
|
||||
|
||||
f_q = open(os.path.expanduser(args.question))
|
||||
f_ans1 = open(os.path.expanduser(args.answer_list[0]))
|
||||
f_ans2 = open(os.path.expanduser(args.answer_list[1]))
|
||||
rule_dict = json.load(open(os.path.expanduser(args.rule), 'r'))
|
||||
|
||||
review_file = open(f'{args.output}', 'w')
|
||||
|
||||
js_list = []
|
||||
handles = []
|
||||
idx = 0
|
||||
for ques_js, ans1_js, ans2_js in zip(f_q, f_ans1, f_ans2):
|
||||
# if idx == 1:
|
||||
# break
|
||||
|
||||
ques = json.loads(ques_js)
|
||||
ans1 = json.loads(ans1_js)
|
||||
ans2 = json.loads(ans2_js)
|
||||
|
||||
category = json.loads(ques_js)['category']
|
||||
if category in rule_dict:
|
||||
rule = rule_dict[category]
|
||||
else:
|
||||
rule = rule_dict['default']
|
||||
prompt = rule['prompt']
|
||||
role = rule['role']
|
||||
content = (f'[Question]\n{ques["text"]}\n\n'
|
||||
f'[{role} 1]\n{ans1["text"]}\n\n[End of {role} 1]\n\n'
|
||||
f'[{role} 2]\n{ans2["text"]}\n\n[End of {role} 2]\n\n'
|
||||
f'[System]\n{prompt}\n\n')
|
||||
js_list.append({
|
||||
'id': idx+1,
|
||||
'question_id': ques['question_id'],
|
||||
'answer1_id': ans1['answer_id'],
|
||||
'answer2_id': ans2['answer_id'],
|
||||
'category': category})
|
||||
idx += 1
|
||||
handles.append(get_eval.remote(content, args.max_tokens))
|
||||
# To avoid the rate limit set by OpenAI
|
||||
time.sleep(1)
|
||||
|
||||
reviews = ray.get(handles)
|
||||
for idx, review in enumerate(reviews):
|
||||
scores = parse_score(review)
|
||||
js_list[idx]['content'] = review
|
||||
js_list[idx]['tuple'] = scores
|
||||
review_file.write(json.dumps(js_list[idx]) + '\n')
|
||||
review_file.close()
|
||||
@@ -1,116 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
|
||||
import openai
|
||||
import tqdm
|
||||
import ray
|
||||
import time
|
||||
|
||||
@ray.remote(num_cpus=4)
|
||||
def get_eval(content: str, max_tokens: int):
|
||||
while True:
|
||||
try:
|
||||
response = openai.ChatCompletion.create(
|
||||
model='gpt-4',
|
||||
messages=[{
|
||||
'role': 'system',
|
||||
'content': 'You are a helpful and precise assistant for checking the quality of the answer.'
|
||||
}, {
|
||||
'role': 'user',
|
||||
'content': content,
|
||||
}],
|
||||
temperature=0.2, # TODO: figure out which temperature is best for evaluation
|
||||
max_tokens=max_tokens,
|
||||
)
|
||||
break
|
||||
except openai.error.RateLimitError:
|
||||
pass
|
||||
except Exception as e:
|
||||
print(e)
|
||||
time.sleep(1)
|
||||
|
||||
print('success!')
|
||||
return response['choices'][0]['message']['content']
|
||||
|
||||
|
||||
def parse_score(review):
|
||||
try:
|
||||
score_pair = review.split('\n')[0]
|
||||
score_pair = score_pair.replace(',', ' ')
|
||||
sp = score_pair.split(' ')
|
||||
if len(sp) == 2:
|
||||
return [float(sp[0]), float(sp[1])]
|
||||
else:
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
except Exception as e:
|
||||
print(e)
|
||||
print('error', review)
|
||||
return [-1, -1]
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description='ChatGPT-based QA evaluation.')
|
||||
parser.add_argument('-q', '--question')
|
||||
parser.add_argument('-c', '--context')
|
||||
parser.add_argument('-a', '--answer-list', nargs='+', default=[])
|
||||
parser.add_argument('-r', '--rule')
|
||||
parser.add_argument('-o', '--output')
|
||||
parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
|
||||
args = parser.parse_args()
|
||||
|
||||
ray.init()
|
||||
|
||||
f_q = open(os.path.expanduser(args.question))
|
||||
f_ans1 = open(os.path.expanduser(args.answer_list[0]))
|
||||
f_ans2 = open(os.path.expanduser(args.answer_list[1]))
|
||||
rule_dict = json.load(open(os.path.expanduser(args.rule), 'r'))
|
||||
|
||||
review_file = open(f'{args.output}', 'w')
|
||||
|
||||
context_list = [json.loads(line) for line in open(os.path.expanduser(args.context))]
|
||||
image_to_context = {context['image']: context for context in context_list}
|
||||
|
||||
js_list = []
|
||||
handles = []
|
||||
idx = 0
|
||||
for ques_js, ans1_js, ans2_js in zip(f_q, f_ans1, f_ans2):
|
||||
ques = json.loads(ques_js)
|
||||
ans1 = json.loads(ans1_js)
|
||||
ans2 = json.loads(ans2_js)
|
||||
|
||||
inst = image_to_context[ques['image']]
|
||||
cap_str = '\n'.join(inst['captions'])
|
||||
box_str = '\n'.join([f'{instance["category"]}: {instance["bbox"]}' for instance in inst['instances']])
|
||||
|
||||
category = json.loads(ques_js)['category']
|
||||
if category in rule_dict:
|
||||
rule = rule_dict[category]
|
||||
else:
|
||||
assert False, f"Visual QA category not found in rule file: {category}."
|
||||
prompt = rule['prompt']
|
||||
role = rule['role']
|
||||
content = (f'[Context]\n{cap_str}\n\n{box_str}\n\n'
|
||||
f'[Question]\n{ques["text"]}\n\n'
|
||||
f'[{role} 1]\n{ans1["text"]}\n\n[End of {role} 1]\n\n'
|
||||
f'[{role} 2]\n{ans2["text"]}\n\n[End of {role} 2]\n\n'
|
||||
f'[System]\n{prompt}\n\n')
|
||||
js_list.append({
|
||||
'id': idx+1,
|
||||
'question_id': ques['question_id'],
|
||||
'answer1_id': ans1.get('answer_id', ans1['question_id']),
|
||||
'answer2_id': ans2.get('answer_id', ans2['answer_id']),
|
||||
'category': category})
|
||||
idx += 1
|
||||
handles.append(get_eval.remote(content, args.max_tokens))
|
||||
# To avoid the rate limit set by OpenAI
|
||||
time.sleep(1)
|
||||
|
||||
reviews = ray.get(handles)
|
||||
for idx, review in enumerate(reviews):
|
||||
scores = parse_score(review)
|
||||
js_list[idx]['content'] = review
|
||||
js_list[idx]['tuple'] = scores
|
||||
review_file.write(json.dumps(js_list[idx]) + '\n')
|
||||
review_file.close()
|
||||
@@ -1,99 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import random
|
||||
|
||||
|
||||
def get_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--base-dir', type=str)
|
||||
parser.add_argument('--result-file', type=str)
|
||||
parser.add_argument('--output-file', type=str)
|
||||
parser.add_argument('--output-result', type=str)
|
||||
parser.add_argument('--split', type=str, default='test')
|
||||
parser.add_argument('--options', type=list, default=["A", "B", "C", "D", "E"])
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def convert_caps(results):
|
||||
fakecaps = []
|
||||
for result in results:
|
||||
image_id = result['question_id']
|
||||
caption = result['text']
|
||||
fakecaps.append({"image_id": int(image_id), "caption": caption})
|
||||
return fakecaps
|
||||
|
||||
|
||||
def get_pred_idx(prediction, choices, options):
|
||||
"""
|
||||
Get the index (e.g. 2) from the prediction (e.g. 'C')
|
||||
"""
|
||||
if prediction in options[:len(choices)]:
|
||||
return options.index(prediction)
|
||||
else:
|
||||
return random.choice(range(len(choices)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
args = get_args()
|
||||
|
||||
base_dir = args.base_dir
|
||||
split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[args.split]
|
||||
problems = json.load(open(os.path.join(base_dir, "problems.json")))
|
||||
predictions = [json.loads(line) for line in open(args.result_file)]
|
||||
predictions = {pred['question_id']: pred for pred in predictions}
|
||||
split_problems = {idx: problems[idx] for idx in split_indices}
|
||||
|
||||
results = {'correct': [], 'incorrect': []}
|
||||
sqa_results = {}
|
||||
sqa_results['acc'] = None
|
||||
sqa_results['correct'] = None
|
||||
sqa_results['count'] = None
|
||||
sqa_results['results'] = {}
|
||||
sqa_results['outputs'] = {}
|
||||
|
||||
for prob_id, prob in split_problems.items():
|
||||
if prob_id not in predictions:
|
||||
continue
|
||||
pred = predictions[prob_id]
|
||||
pred_text = pred['text']
|
||||
|
||||
pattern = re.compile(r'The answer is ([A-Z]).')
|
||||
res = pattern.findall(pred_text)
|
||||
if len(res) == 1:
|
||||
answer = res[0] # 'A', 'B', ...
|
||||
else:
|
||||
answer = "FAILED"
|
||||
|
||||
pred_idx = get_pred_idx(answer, prob['choices'], args.options)
|
||||
|
||||
analysis = {
|
||||
'question_id': prob_id,
|
||||
'parsed_ans': answer,
|
||||
'ground_truth': args.options[prob['answer']],
|
||||
'question': pred['prompt'],
|
||||
'pred': pred_text,
|
||||
'is_multimodal': '<image>' in pred['prompt'],
|
||||
}
|
||||
|
||||
sqa_results['results'][prob_id] = get_pred_idx(answer, prob['choices'], args.options)
|
||||
sqa_results['outputs'][prob_id] = pred_text
|
||||
|
||||
if pred_idx == prob['answer']:
|
||||
results['correct'].append(analysis)
|
||||
else:
|
||||
results['incorrect'].append(analysis)
|
||||
|
||||
correct = len(results['correct'])
|
||||
total = len(results['correct']) + len(results['incorrect'])
|
||||
print(f'Total: {total}, Correct: {correct}, Accuracy: {correct / total * 100:.2f}%')
|
||||
|
||||
sqa_results['acc'] = correct / total * 100
|
||||
sqa_results['correct'] = correct
|
||||
sqa_results['count'] = total
|
||||
|
||||
with open(args.output_file, 'w') as f:
|
||||
json.dump(results, f, indent=2)
|
||||
with open(args.output_result, 'w') as f:
|
||||
json.dump(sqa_results, f, indent=2)
|
||||
@@ -1,104 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import random
|
||||
from collections import defaultdict
|
||||
|
||||
|
||||
def get_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--base-dir', type=str)
|
||||
parser.add_argument('--gpt4-result', type=str)
|
||||
parser.add_argument('--our-result', type=str)
|
||||
parser.add_argument('--split', type=str, default='test')
|
||||
parser.add_argument('--options', type=list, default=["A", "B", "C", "D", "E"])
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def convert_caps(results):
|
||||
fakecaps = []
|
||||
for result in results:
|
||||
image_id = result['question_id']
|
||||
caption = result['text']
|
||||
fakecaps.append({"image_id": int(image_id), "caption": caption})
|
||||
return fakecaps
|
||||
|
||||
|
||||
def get_pred_idx(prediction, choices, options):
|
||||
"""
|
||||
Get the index (e.g. 2) from the prediction (e.g. 'C')
|
||||
"""
|
||||
if prediction in options[:len(choices)]:
|
||||
return options.index(prediction)
|
||||
else:
|
||||
return random.choice(range(len(choices)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
args = get_args()
|
||||
|
||||
base_dir = args.base_dir
|
||||
split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[args.split]
|
||||
problems = json.load(open(os.path.join(base_dir, "problems.json")))
|
||||
our_predictions = [json.loads(line) for line in open(args.our_result)]
|
||||
our_predictions = {pred['question_id']: pred for pred in our_predictions}
|
||||
split_problems = {idx: problems[idx] for idx in split_indices}
|
||||
|
||||
gpt4_predictions = json.load(open(args.gpt4_result))['outputs']
|
||||
|
||||
results = defaultdict(lambda: 0)
|
||||
|
||||
for prob_id, prob in split_problems.items():
|
||||
if prob_id not in our_predictions:
|
||||
continue
|
||||
if prob_id not in gpt4_predictions:
|
||||
continue
|
||||
our_pred = our_predictions[prob_id]['text']
|
||||
gpt4_pred = gpt4_predictions[prob_id]
|
||||
|
||||
pattern = re.compile(r'The answer is ([A-Z]).')
|
||||
our_res = pattern.findall(our_pred)
|
||||
if len(our_res) == 1:
|
||||
our_answer = our_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
our_answer = "FAILED"
|
||||
gpt4_res = pattern.findall(gpt4_pred)
|
||||
if len(gpt4_res) == 1:
|
||||
gpt4_answer = gpt4_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
gpt4_answer = "FAILED"
|
||||
|
||||
our_pred_idx = get_pred_idx(our_answer, prob['choices'], args.options)
|
||||
gpt4_pred_idx = get_pred_idx(gpt4_answer, prob['choices'], args.options)
|
||||
|
||||
if gpt4_answer == 'FAILED':
|
||||
results['gpt4_failed'] += 1
|
||||
# continue
|
||||
gpt4_pred_idx = our_pred_idx
|
||||
# if our_pred_idx != prob['answer']:
|
||||
# print(our_predictions[prob_id]['prompt'])
|
||||
# print('-----------------')
|
||||
# print(f'LECTURE: {prob["lecture"]}')
|
||||
# print(f'SOLUTION: {prob["solution"]}')
|
||||
# print('=====================')
|
||||
else:
|
||||
# continue
|
||||
pass
|
||||
# gpt4_pred_idx = our_pred_idx
|
||||
|
||||
if gpt4_pred_idx == prob['answer']:
|
||||
results['correct'] += 1
|
||||
else:
|
||||
results['incorrect'] += 1
|
||||
|
||||
|
||||
if gpt4_pred_idx == prob['answer'] or our_pred_idx == prob['answer']:
|
||||
results['correct_upperbound'] += 1
|
||||
|
||||
correct = results['correct']
|
||||
total = results['correct'] + results['incorrect']
|
||||
print(f'Total: {total}, Correct: {correct}, Accuracy: {correct / total * 100:.2f}%')
|
||||
print(f'Total: {total}, Correct (upper): {results["correct_upperbound"]}, Accuracy: {results["correct_upperbound"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4 NO-ANS (RANDOM): {results["gpt4_failed"]}, Percentage: {results["gpt4_failed"] / total * 100:.2f}%')
|
||||
|
||||
@@ -1,149 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import random
|
||||
from collections import defaultdict
|
||||
|
||||
|
||||
def get_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('--base-dir', type=str)
|
||||
parser.add_argument('--gpt4-result', type=str)
|
||||
parser.add_argument('--requery-result', type=str)
|
||||
parser.add_argument('--our-result', type=str)
|
||||
parser.add_argument('--output-result', type=str)
|
||||
parser.add_argument('--split', type=str, default='test')
|
||||
parser.add_argument('--options', type=list, default=["A", "B", "C", "D", "E"])
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def convert_caps(results):
|
||||
fakecaps = []
|
||||
for result in results:
|
||||
image_id = result['question_id']
|
||||
caption = result['text']
|
||||
fakecaps.append({"image_id": int(image_id), "caption": caption})
|
||||
return fakecaps
|
||||
|
||||
|
||||
def get_pred_idx(prediction, choices, options):
|
||||
"""
|
||||
Get the index (e.g. 2) from the prediction (e.g. 'C')
|
||||
"""
|
||||
if prediction in options[:len(choices)]:
|
||||
return options.index(prediction)
|
||||
else:
|
||||
return random.choice(range(len(choices)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
args = get_args()
|
||||
|
||||
base_dir = args.base_dir
|
||||
split_indices = json.load(open(os.path.join(base_dir, "pid_splits.json")))[args.split]
|
||||
problems = json.load(open(os.path.join(base_dir, "problems.json")))
|
||||
our_predictions = [json.loads(line) for line in open(args.our_result)]
|
||||
our_predictions = {pred['question_id']: pred for pred in our_predictions}
|
||||
split_problems = {idx: problems[idx] for idx in split_indices}
|
||||
|
||||
requery_predictions = [json.loads(line) for line in open(args.requery_result)]
|
||||
requery_predictions = {pred['question_id']: pred for pred in requery_predictions}
|
||||
|
||||
gpt4_predictions = json.load(open(args.gpt4_result))['outputs']
|
||||
|
||||
results = defaultdict(lambda: 0)
|
||||
|
||||
sqa_results = {}
|
||||
sqa_results['acc'] = None
|
||||
sqa_results['correct'] = None
|
||||
sqa_results['count'] = None
|
||||
sqa_results['results'] = {}
|
||||
sqa_results['outputs'] = {}
|
||||
|
||||
for prob_id, prob in split_problems.items():
|
||||
if prob_id not in our_predictions:
|
||||
assert False
|
||||
if prob_id not in gpt4_predictions:
|
||||
assert False
|
||||
our_pred = our_predictions[prob_id]['text']
|
||||
gpt4_pred = gpt4_predictions[prob_id]
|
||||
if prob_id not in requery_predictions:
|
||||
results['missing_requery'] += 1
|
||||
requery_pred = "MISSING"
|
||||
else:
|
||||
requery_pred = requery_predictions[prob_id]['text']
|
||||
|
||||
pattern = re.compile(r'The answer is ([A-Z]).')
|
||||
our_res = pattern.findall(our_pred)
|
||||
if len(our_res) == 1:
|
||||
our_answer = our_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
our_answer = "FAILED"
|
||||
|
||||
requery_res = pattern.findall(requery_pred)
|
||||
if len(requery_res) == 1:
|
||||
requery_answer = requery_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
requery_answer = "FAILED"
|
||||
|
||||
gpt4_res = pattern.findall(gpt4_pred)
|
||||
if len(gpt4_res) == 1:
|
||||
gpt4_answer = gpt4_res[0] # 'A', 'B', ...
|
||||
else:
|
||||
gpt4_answer = "FAILED"
|
||||
|
||||
our_pred_idx = get_pred_idx(our_answer, prob['choices'], args.options)
|
||||
gpt4_pred_idx = get_pred_idx(gpt4_answer, prob['choices'], args.options)
|
||||
requery_pred_idx = get_pred_idx(requery_answer, prob['choices'], args.options)
|
||||
|
||||
results['total'] += 1
|
||||
|
||||
if gpt4_answer == 'FAILED':
|
||||
results['gpt4_failed'] += 1
|
||||
if gpt4_pred_idx == prob['answer']:
|
||||
results['gpt4_correct'] += 1
|
||||
if our_pred_idx == prob['answer']:
|
||||
results['gpt4_ourvisual_correct'] += 1
|
||||
elif gpt4_pred_idx == prob['answer']:
|
||||
results['gpt4_correct'] += 1
|
||||
results['gpt4_ourvisual_correct'] += 1
|
||||
|
||||
if our_pred_idx == prob['answer']:
|
||||
results['our_correct'] += 1
|
||||
|
||||
if requery_answer == 'FAILED':
|
||||
sqa_results['results'][prob_id] = our_pred_idx
|
||||
if our_pred_idx == prob['answer']:
|
||||
results['requery_correct'] += 1
|
||||
else:
|
||||
sqa_results['results'][prob_id] = requery_pred_idx
|
||||
if requery_pred_idx == prob['answer']:
|
||||
results['requery_correct'] += 1
|
||||
else:
|
||||
print(f"""
|
||||
Question ({args.options[prob['answer']]}): {our_predictions[prob_id]['prompt']}
|
||||
Our ({our_answer}): {our_pred}
|
||||
GPT-4 ({gpt4_answer}): {gpt4_pred}
|
||||
Requery ({requery_answer}): {requery_pred}
|
||||
print("=====================================")
|
||||
""")
|
||||
|
||||
if gpt4_pred_idx == prob['answer'] or our_pred_idx == prob['answer']:
|
||||
results['correct_upperbound'] += 1
|
||||
|
||||
total = results['total']
|
||||
print(f'Total: {total}, Our-Correct: {results["our_correct"]}, Accuracy: {results["our_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4-Correct: {results["gpt4_correct"]}, Accuracy: {results["gpt4_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4 NO-ANS (RANDOM): {results["gpt4_failed"]}, Percentage: {results["gpt4_failed"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, GPT-4-OursVisual-Correct: {results["gpt4_ourvisual_correct"]}, Accuracy: {results["gpt4_ourvisual_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, Requery-Correct: {results["requery_correct"]}, Accuracy: {results["requery_correct"] / total * 100:.2f}%')
|
||||
print(f'Total: {total}, Correct upper: {results["correct_upperbound"]}, Accuracy: {results["correct_upperbound"] / total * 100:.2f}%')
|
||||
|
||||
sqa_results['acc'] = results["requery_correct"] / total * 100
|
||||
sqa_results['correct'] = results["requery_correct"]
|
||||
sqa_results['count'] = total
|
||||
|
||||
with open(args.output_result, 'w') as f:
|
||||
json.dump(sqa_results, f, indent=2)
|
||||
|
||||
@@ -1,111 +0,0 @@
|
||||
"""Generate json file for webpage."""
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
|
||||
# models = ['llama', 'alpaca', 'gpt35', 'bard']
|
||||
models = ['vicuna']
|
||||
|
||||
|
||||
def read_jsonl(path: str, key: str=None):
|
||||
data = []
|
||||
with open(os.path.expanduser(path)) as f:
|
||||
for line in f:
|
||||
if not line:
|
||||
continue
|
||||
data.append(json.loads(line))
|
||||
if key is not None:
|
||||
data.sort(key=lambda x: x[key])
|
||||
data = {item[key]: item for item in data}
|
||||
return data
|
||||
|
||||
|
||||
def trim_hanging_lines(s: str, n: int) -> str:
|
||||
s = s.strip()
|
||||
for _ in range(n):
|
||||
s = s.split('\n', 1)[1].strip()
|
||||
return s
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
questions = read_jsonl('table/question.jsonl', key='question_id')
|
||||
|
||||
# alpaca_answers = read_jsonl('table/answer/answer_alpaca-13b.jsonl', key='question_id')
|
||||
# bard_answers = read_jsonl('table/answer/answer_bard.jsonl', key='question_id')
|
||||
# gpt35_answers = read_jsonl('table/answer/answer_gpt35.jsonl', key='question_id')
|
||||
# llama_answers = read_jsonl('table/answer/answer_llama-13b.jsonl', key='question_id')
|
||||
vicuna_answers = read_jsonl('table/answer/answer_vicuna-13b.jsonl', key='question_id')
|
||||
ours_answers = read_jsonl('table/results/llama-13b-hf-alpaca.jsonl', key='question_id')
|
||||
|
||||
review_vicuna = read_jsonl('table/review/review_vicuna-13b_llama-13b-hf-alpaca.jsonl', key='question_id')
|
||||
# review_alpaca = read_jsonl('table/review/review_alpaca-13b_vicuna-13b.jsonl', key='question_id')
|
||||
# review_bard = read_jsonl('table/review/review_bard_vicuna-13b.jsonl', key='question_id')
|
||||
# review_gpt35 = read_jsonl('table/review/review_gpt35_vicuna-13b.jsonl', key='question_id')
|
||||
# review_llama = read_jsonl('table/review/review_llama-13b_vicuna-13b.jsonl', key='question_id')
|
||||
|
||||
records = []
|
||||
for qid in questions.keys():
|
||||
r = {
|
||||
'id': qid,
|
||||
'category': questions[qid]['category'],
|
||||
'question': questions[qid]['text'],
|
||||
'answers': {
|
||||
# 'alpaca': alpaca_answers[qid]['text'],
|
||||
# 'llama': llama_answers[qid]['text'],
|
||||
# 'bard': bard_answers[qid]['text'],
|
||||
# 'gpt35': gpt35_answers[qid]['text'],
|
||||
'vicuna': vicuna_answers[qid]['text'],
|
||||
'ours': ours_answers[qid]['text'],
|
||||
},
|
||||
'evaluations': {
|
||||
# 'alpaca': review_alpaca[qid]['text'],
|
||||
# 'llama': review_llama[qid]['text'],
|
||||
# 'bard': review_bard[qid]['text'],
|
||||
'vicuna': review_vicuna[qid]['content'],
|
||||
# 'gpt35': review_gpt35[qid]['text'],
|
||||
},
|
||||
'scores': {
|
||||
'vicuna': review_vicuna[qid]['tuple'],
|
||||
# 'alpaca': review_alpaca[qid]['score'],
|
||||
# 'llama': review_llama[qid]['score'],
|
||||
# 'bard': review_bard[qid]['score'],
|
||||
# 'gpt35': review_gpt35[qid]['score'],
|
||||
},
|
||||
}
|
||||
|
||||
# cleanup data
|
||||
cleaned_evals = {}
|
||||
for k, v in r['evaluations'].items():
|
||||
v = v.strip()
|
||||
lines = v.split('\n')
|
||||
# trim the first line if it's a pair of numbers
|
||||
if re.match(r'\d+[, ]+\d+', lines[0]):
|
||||
lines = lines[1:]
|
||||
v = '\n'.join(lines)
|
||||
cleaned_evals[k] = v.replace('Assistant 1', "**Assistant 1**").replace('Assistant 2', '**Assistant 2**')
|
||||
|
||||
r['evaluations'] = cleaned_evals
|
||||
records.append(r)
|
||||
|
||||
# Reorder the records, this is optional
|
||||
for r in records:
|
||||
if r['id'] <= 20:
|
||||
r['id'] += 60
|
||||
else:
|
||||
r['id'] -= 20
|
||||
for r in records:
|
||||
if r['id'] <= 50:
|
||||
r['id'] += 10
|
||||
elif 50 < r['id'] <= 60:
|
||||
r['id'] -= 50
|
||||
for r in records:
|
||||
if r['id'] == 7:
|
||||
r['id'] = 1
|
||||
elif r['id'] < 7:
|
||||
r['id'] += 1
|
||||
|
||||
records.sort(key=lambda x: x['id'])
|
||||
|
||||
# Write to file
|
||||
with open('webpage/data.json', 'w') as f:
|
||||
json.dump({'questions': records, 'models': models}, f, indent=2)
|
||||
@@ -1,84 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM, StoppingCriteria
|
||||
import torch
|
||||
import os
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
import shortuuid
|
||||
|
||||
from llava.conversation import default_conversation
|
||||
from llava.utils import disable_torch_init
|
||||
|
||||
|
||||
# new stopping implementation
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
@torch.inference_mode()
|
||||
def eval_model(model_name, questions_file, answers_file):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
model = AutoModelForCausalLM.from_pretrained(model_name,
|
||||
torch_dtype=torch.float16).cuda()
|
||||
|
||||
|
||||
ques_file = open(os.path.expanduser(questions_file), "r")
|
||||
ans_file = open(os.path.expanduser(answers_file), "w")
|
||||
for i, line in enumerate(tqdm(ques_file)):
|
||||
idx = json.loads(line)["question_id"]
|
||||
qs = json.loads(line)["text"]
|
||||
cat = json.loads(line)["category"]
|
||||
conv = default_conversation.copy()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
stopping_criteria = KeywordsStoppingCriteria([conv.sep], tokenizer, input_ids)
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]
|
||||
try:
|
||||
index = outputs.index(conv.sep, len(prompt))
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep, len(prompt))
|
||||
|
||||
outputs = outputs[len(prompt) + len(conv.roles[1]) + 2:index].strip()
|
||||
ans_id = shortuuid.uuid()
|
||||
ans_file.write(json.dumps({"question_id": idx,
|
||||
"text": outputs,
|
||||
"answer_id": ans_id,
|
||||
"model_id": model_name,
|
||||
"metadata": {}}) + "\n")
|
||||
ans_file.flush()
|
||||
ans_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--question-file", type=str, default="tables/question.jsonl")
|
||||
parser.add_argument("--answers-file", type=str, default="answer.jsonl")
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args.model_name, args.question_file, args.answers_file)
|
||||
@@ -1,207 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig
|
||||
import torch
|
||||
import os
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
import shortuuid
|
||||
|
||||
from llava import LlavaLlamaForCausalLM
|
||||
from llava.conversation import conv_templates
|
||||
from llava.utils import disable_torch_init
|
||||
from transformers import CLIPVisionModel, CLIPImageProcessor, StoppingCriteria
|
||||
|
||||
from PIL import Image
|
||||
import random
|
||||
import math
|
||||
|
||||
|
||||
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]
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
def patch_config(config):
|
||||
patch_dict = {
|
||||
"use_mm_proj": True,
|
||||
"mm_vision_tower": "openai/clip-vit-large-patch14",
|
||||
"mm_hidden_size": 1024
|
||||
}
|
||||
|
||||
cfg = AutoConfig.from_pretrained(config)
|
||||
if not hasattr(cfg, "mm_vision_tower"):
|
||||
print(f'`mm_vision_tower` not found in `{config}`, applying patch and save to disk.')
|
||||
for k, v in patch_dict.items():
|
||||
setattr(cfg, k, v)
|
||||
cfg.save_pretrained(config)
|
||||
|
||||
|
||||
def eval_model(args):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(args.model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
if args.mm_projector is None:
|
||||
patch_config(model_name)
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.model.vision_tower[0]
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
else:
|
||||
# in case of using a pretrained model with only a MLP projector weights
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16).cuda()
|
||||
|
||||
vision_tower = CLIPVisionModel.from_pretrained(args.vision_tower, torch_dtype=torch.float16).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(args.vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
mm_projector = torch.nn.Linear(vision_config.hidden_size, model.config.hidden_size)
|
||||
mm_projector_weights = torch.load(args.mm_projector, map_location='cpu')
|
||||
mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items()})
|
||||
|
||||
model.model.mm_projector = mm_projector.cuda().half()
|
||||
model.model.vision_tower = [vision_tower]
|
||||
|
||||
questions = [json.loads(q) for q in open(os.path.expanduser(args.question_file), "r")]
|
||||
questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
|
||||
answers_file = os.path.expanduser(args.answers_file)
|
||||
os.makedirs(os.path.dirname(answers_file), exist_ok=True)
|
||||
ans_file = open(answers_file, "w")
|
||||
for i, line in enumerate(tqdm(questions)):
|
||||
idx = line["question_id"]
|
||||
image_file = line["image"]
|
||||
qs = line["text"]
|
||||
cur_prompt = qs
|
||||
if mm_use_im_start_end:
|
||||
qs = qs + '\n' + DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len + DEFAULT_IM_END_TOKEN
|
||||
else:
|
||||
qs = qs + '\n' + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
|
||||
if args.conv_mode == 'simple_legacy':
|
||||
qs += '\n\n### Response:'
|
||||
# conv = default_conversation.copy()
|
||||
conv = conv_templates[args.conv_mode].copy()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
|
||||
image = Image.open(os.path.join(args.image_folder, image_file))
|
||||
# image.save(os.path.join(save_image_folder, image_file))
|
||||
image_tensor = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
# new stopping implementation
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
|
||||
keywords = ['###']
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=image_tensor.unsqueeze(0).half().cuda(),
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] Sample {i}: {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
|
||||
if args.conv_mode == 'simple_legacy' or args.conv_mode == 'simple':
|
||||
while True:
|
||||
cur_len = len(outputs)
|
||||
outputs = outputs.strip()
|
||||
for pattern in ['###', 'Assistant:', 'Response:']:
|
||||
if outputs.startswith(pattern):
|
||||
outputs = outputs[len(pattern):].strip()
|
||||
if len(outputs) == cur_len:
|
||||
break
|
||||
|
||||
try:
|
||||
index = outputs.index(conv.sep)
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep)
|
||||
|
||||
outputs = outputs[:index].strip()
|
||||
|
||||
ans_id = shortuuid.uuid()
|
||||
ans_file.write(json.dumps({"question_id": idx,
|
||||
"prompt": cur_prompt,
|
||||
"text": outputs,
|
||||
"answer_id": ans_id,
|
||||
"model_id": model_name,
|
||||
"metadata": {}}) + "\n")
|
||||
ans_file.flush()
|
||||
ans_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--image-folder", type=str, default="")
|
||||
parser.add_argument("--question-file", type=str, default="tables/question.jsonl")
|
||||
parser.add_argument("--answers-file", type=str, default="answer.jsonl")
|
||||
parser.add_argument("--mm-projector", type=str, default=None)
|
||||
parser.add_argument("--vision-tower", type=str, default=None)
|
||||
parser.add_argument("--conv-mode", type=str, default="simple")
|
||||
parser.add_argument("--num-chunks", type=int, default=1)
|
||||
parser.add_argument("--chunk-idx", type=int, default=0)
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args)
|
||||
@@ -1,309 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig
|
||||
import torch
|
||||
import os
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
import shortuuid
|
||||
|
||||
from llava import LlavaLlamaForCausalLM
|
||||
from llava.conversation import conv_templates
|
||||
from llava.utils import disable_torch_init
|
||||
from transformers import CLIPVisionModel, CLIPImageProcessor, StoppingCriteria
|
||||
|
||||
from PIL import Image
|
||||
import random
|
||||
import math
|
||||
|
||||
|
||||
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]
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
|
||||
|
||||
detail_describe_instructions = [
|
||||
"Describe the following image in detail.",
|
||||
"Provide a detailed description of the given image.",
|
||||
"Give an elaborate explanation of the image you see.",
|
||||
"Share a comprehensive rundown of the presented image.",
|
||||
"Offer a thorough analysis of the image.",
|
||||
"Explain the various aspects of the image before you.",
|
||||
"Clarify the contents of the displayed image with great detail.",
|
||||
"Characterize the image using a well-detailed description.",
|
||||
"Break down the elements of the image in a detailed manner.",
|
||||
"Walk through the important details of the image.",
|
||||
"Portray the image with a rich, descriptive narrative.",
|
||||
"Narrate the contents of the image with precision.",
|
||||
"Analyze the image in a comprehensive and detailed manner.",
|
||||
"Illustrate the image through a descriptive explanation.",
|
||||
"Examine the image closely and share its details.",
|
||||
"Write an exhaustive depiction of the given image.",
|
||||
]
|
||||
|
||||
concise_describe_instructions = [
|
||||
"Describe the following image concisely.",
|
||||
"Provide a brief description of the given image.",
|
||||
"Offer a succinct explanation of the picture presented.",
|
||||
"Summarize the visual content of the following image.",
|
||||
"Give a short and clear explanation of the subsequent image.",
|
||||
"Share a concise interpretation of the image provided.",
|
||||
"Present a compact description of the photo's key features.",
|
||||
"Relay a brief, clear account of the picture shown.",
|
||||
"Render a clear and concise summary of the photo below.",
|
||||
"Write a terse but informative summary of the following picture.",
|
||||
"Create a compact narrative representing the image presented.",
|
||||
]
|
||||
|
||||
prompt_pool = detail_describe_instructions + concise_describe_instructions
|
||||
|
||||
prompt_pool = [ "Describe the following image in detail."]
|
||||
|
||||
|
||||
def patch_config(config):
|
||||
patch_dict = {
|
||||
"use_mm_proj": True,
|
||||
"mm_vision_tower": "openai/clip-vit-large-patch14",
|
||||
"mm_hidden_size": 1024
|
||||
}
|
||||
|
||||
cfg = AutoConfig.from_pretrained(config)
|
||||
if not hasattr(cfg, "mm_vision_tower"):
|
||||
print(f'`mm_vision_tower` not found in `{config}`, applying patch and save to disk.')
|
||||
for k, v in patch_dict.items():
|
||||
setattr(cfg, k, v)
|
||||
cfg.save_pretrained(config)
|
||||
|
||||
|
||||
# new stopping implementation
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def eval_model(args):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(args.model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
if args.mm_projector is None:
|
||||
patch_config(model_name)
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.model.vision_tower[0]
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
else:
|
||||
# in case of using a pretrained model with only a MLP projector weights
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = CLIPVisionModel.from_pretrained(args.vision_tower, torch_dtype=torch.float16).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(args.vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
mm_projector = torch.nn.Linear(vision_config.hidden_size, model.config.hidden_size)
|
||||
mm_projector_weights = torch.load(args.mm_projector, map_location='cpu')
|
||||
mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items()})
|
||||
|
||||
model.model.mm_projector = mm_projector.cuda().half()
|
||||
model.model.vision_tower = [vision_tower]
|
||||
|
||||
questions = json.load(open(os.path.expanduser(args.question_file), "r"))
|
||||
questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
|
||||
answers_file = os.path.expanduser(args.answers_file)
|
||||
os.makedirs(os.path.dirname(answers_file), exist_ok=True)
|
||||
os.makedirs(os.path.join(os.path.dirname(answers_file), "images"), exist_ok=True)
|
||||
ans_file = open(answers_file, "w")
|
||||
save_image_folder = os.path.join(os.path.dirname(os.path.expanduser(args.answers_file)), "images")
|
||||
for i, line in enumerate(tqdm(questions)):
|
||||
idx = line["id"]
|
||||
question = line['conversations'][0]
|
||||
gt_ans = line["conversations"][1]
|
||||
|
||||
qs = question['value']
|
||||
|
||||
qs = qs.replace('<image>', '').strip()
|
||||
cur_prompt = qs
|
||||
|
||||
if 'image' in line:
|
||||
image_file = line["image"]
|
||||
image = Image.open(os.path.join(args.image_folder, image_file))
|
||||
image_tensor = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
|
||||
images = image_tensor.unsqueeze(0).half().cuda()
|
||||
if getattr(model.config, 'mm_use_im_start_end', False):
|
||||
qs = qs + '\n' + DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len + DEFAULT_IM_END_TOKEN
|
||||
else:
|
||||
qs = qs + '\n' + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
cur_prompt = cur_prompt + '\n' + '<image>'
|
||||
else:
|
||||
images = None
|
||||
|
||||
if args.conv_mode == 'simple_legacy':
|
||||
qs += '\n\n### Response:'
|
||||
assert gt_ans['from'] == 'gpt'
|
||||
# conv = default_conversation.copy()
|
||||
conv = conv_templates[args.conv_mode].copy()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
keywords = ['###']
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=images,
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
# TODO: new implementation
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] Sample {i}: {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
|
||||
if args.conv_mode == 'simple_legacy':
|
||||
while True:
|
||||
cur_len = len(outputs)
|
||||
outputs = outputs.strip()
|
||||
for pattern in ['###', 'Assistant:', 'Response:']:
|
||||
if outputs.startswith(pattern):
|
||||
outputs = outputs[len(pattern):].strip()
|
||||
if len(outputs) == cur_len:
|
||||
break
|
||||
|
||||
try:
|
||||
index = outputs.index(conv.sep)
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep)
|
||||
|
||||
outputs = outputs[:index].strip()
|
||||
|
||||
# prompt for answer
|
||||
if args.answer_prompter:
|
||||
outputs_reasoning = outputs
|
||||
inputs = tokenizer([prompt + outputs_reasoning + ' ###\nANSWER:'])
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
keywords = ['###']
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=images,
|
||||
do_sample=True,
|
||||
temperature=0.7,
|
||||
max_new_tokens=64,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] Sample {i}: {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
|
||||
try:
|
||||
index = outputs.index(conv.sep)
|
||||
except ValueError:
|
||||
outputs += conv.sep
|
||||
index = outputs.index(conv.sep)
|
||||
|
||||
outputs = outputs[:index].strip()
|
||||
outputs = outputs_reasoning + '\n The answer is ' + outputs
|
||||
|
||||
# new implementation ends
|
||||
|
||||
# original implementation
|
||||
# outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]
|
||||
# try:
|
||||
# index = outputs.index(conv.sep, len(prompt))
|
||||
# except ValueError:
|
||||
# outputs += conv.sep
|
||||
# index = outputs.index(conv.sep, len(prompt))
|
||||
|
||||
# outputs = outputs[len(prompt) + len(conv.roles[1]) + 2:index].strip()
|
||||
|
||||
|
||||
ans_id = shortuuid.uuid()
|
||||
ans_file.write(json.dumps({"question_id": idx,
|
||||
"prompt": cur_prompt,
|
||||
"text": outputs,
|
||||
"answer_id": ans_id,
|
||||
"model_id": model_name,
|
||||
"metadata": {}}) + "\n")
|
||||
ans_file.flush()
|
||||
ans_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--image-folder", type=str, default="")
|
||||
parser.add_argument("--question-file", type=str, default="tables/question.json")
|
||||
parser.add_argument("--answers-file", type=str, default="answer.jsonl")
|
||||
parser.add_argument("--mm-projector", type=str, default=None)
|
||||
parser.add_argument("--vision-tower", type=str, default=None)
|
||||
parser.add_argument("--conv-mode", type=str, default="simple")
|
||||
parser.add_argument("--num-chunks", type=int, default=1)
|
||||
parser.add_argument("--chunk-idx", type=int, default=0)
|
||||
parser.add_argument("--answer-prompter", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args)
|
||||
@@ -1,74 +0,0 @@
|
||||
"""Generate answers with GPT-3.5"""
|
||||
# Note: you need to be using OpenAI Python v0.27.0 for the code below to work
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
import concurrent.futures
|
||||
|
||||
import openai
|
||||
import tqdm
|
||||
import shortuuid
|
||||
|
||||
MODEL = 'gpt-3.5-turbo'
|
||||
MODEL_ID = 'gpt-3.5-turbo:20230327'
|
||||
|
||||
def get_answer(question_id: int, question: str, max_tokens: int):
|
||||
ans = {
|
||||
'answer_id': shortuuid.uuid(),
|
||||
'question_id': question_id,
|
||||
'model_id': MODEL_ID,
|
||||
}
|
||||
for _ in range(3):
|
||||
try:
|
||||
response = openai.ChatCompletion.create(
|
||||
model=MODEL,
|
||||
messages=[{
|
||||
'role': 'system',
|
||||
'content': 'You are a helpful assistant.'
|
||||
}, {
|
||||
'role': 'user',
|
||||
'content': question,
|
||||
}],
|
||||
max_tokens=max_tokens,
|
||||
)
|
||||
ans['text'] = response['choices'][0]['message']['content']
|
||||
return ans
|
||||
except Exception as e:
|
||||
print('[ERROR]', e)
|
||||
ans['text'] = '#ERROR#'
|
||||
time.sleep(1)
|
||||
return ans
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = argparse.ArgumentParser(description='ChatGPT answer generation.')
|
||||
parser.add_argument('-q', '--question')
|
||||
parser.add_argument('-o', '--output')
|
||||
parser.add_argument('--max-tokens', type=int, default=1024, help='maximum number of tokens produced in the output')
|
||||
args = parser.parse_args()
|
||||
|
||||
questions_dict = {}
|
||||
with open(os.path.expanduser(args.question)) as f:
|
||||
for line in f:
|
||||
if not line:
|
||||
continue
|
||||
q = json.loads(line)
|
||||
questions_dict[q['question_id']] = q['text']
|
||||
|
||||
answers = []
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=32) as executor:
|
||||
futures = []
|
||||
for qid, question in questions_dict.items():
|
||||
future = executor.submit(get_answer, qid, question, args.max_tokens)
|
||||
futures.append(future)
|
||||
|
||||
for future in tqdm.tqdm(concurrent.futures.as_completed(futures), total=len(futures)):
|
||||
answers.append(future.result())
|
||||
|
||||
answers.sort(key=lambda x: x['question_id'])
|
||||
|
||||
with open(os.path.expanduser(args.output), 'w') as f:
|
||||
table = [json.dumps(ans) for ans in answers]
|
||||
f.write('\n'.join(table))
|
||||
@@ -1,125 +0,0 @@
|
||||
import argparse
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
import torch
|
||||
import os
|
||||
from llava.conversation import conv_templates, SeparatorStyle
|
||||
from llava.utils import disable_torch_init
|
||||
from transformers import CLIPVisionModel, CLIPImageProcessor, StoppingCriteria
|
||||
from llava.model import *
|
||||
from llava.model.utils import KeywordsStoppingCriteria
|
||||
|
||||
from PIL import Image
|
||||
|
||||
import os
|
||||
import requests
|
||||
from PIL import Image
|
||||
from io import BytesIO
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
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 eval_model(args):
|
||||
# Model
|
||||
disable_torch_init()
|
||||
model_name = os.path.expanduser(args.model_name)
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
|
||||
if "mpt" in model_name.lower():
|
||||
model = LlavaMPTForCausalLM.from_pretrained(model_name, low_cpu_mem_usage=True, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
else:
|
||||
model = LlavaLlamaForCausalLM.from_pretrained(model_name, low_cpu_mem_usage=True, torch_dtype=torch.float16, use_cache=True).cuda()
|
||||
image_processor = CLIPImageProcessor.from_pretrained(model.config.mm_vision_tower, torch_dtype=torch.float16)
|
||||
|
||||
mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
if mm_use_im_start_end:
|
||||
tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
|
||||
vision_tower = model.get_model().vision_tower[0]
|
||||
if vision_tower.device.type == 'meta':
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower.config._name_or_path, torch_dtype=torch.float16, low_cpu_mem_usage=True).cuda()
|
||||
model.get_model().vision_tower[0] = vision_tower
|
||||
else:
|
||||
vision_tower.to(device='cuda', dtype=torch.float16)
|
||||
vision_config = vision_tower.config
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
if mm_use_im_start_end:
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
image_token_len = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
qs = args.query
|
||||
if mm_use_im_start_end:
|
||||
qs = qs + '\n' + DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len + DEFAULT_IM_END_TOKEN
|
||||
else:
|
||||
qs = qs + '\n' + DEFAULT_IMAGE_PATCH_TOKEN * image_token_len
|
||||
|
||||
if "v1" in model_name.lower():
|
||||
conv_mode = "llava_v1"
|
||||
elif "mpt" in model_name.lower():
|
||||
conv_mode = "mpt_multimodal"
|
||||
else:
|
||||
conv_mode = "multimodal"
|
||||
|
||||
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()
|
||||
conv.append_message(conv.roles[0], qs)
|
||||
conv.append_message(conv.roles[1], None)
|
||||
prompt = conv.get_prompt()
|
||||
inputs = tokenizer([prompt])
|
||||
|
||||
image = load_image(args.image_file)
|
||||
image_tensor = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
|
||||
|
||||
input_ids = torch.as_tensor(inputs.input_ids).cuda()
|
||||
|
||||
stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
|
||||
keywords = [stop_str]
|
||||
stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
|
||||
|
||||
with torch.inference_mode():
|
||||
output_ids = model.generate(
|
||||
input_ids,
|
||||
images=image_tensor.unsqueeze(0).half().cuda(),
|
||||
do_sample=True,
|
||||
temperature=0.2,
|
||||
max_new_tokens=1024,
|
||||
stopping_criteria=[stopping_criteria])
|
||||
|
||||
input_token_len = input_ids.shape[1]
|
||||
n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()
|
||||
if n_diff_input_output > 0:
|
||||
print(f'[Warning] {n_diff_input_output} output_ids are not the same as the input_ids')
|
||||
outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]
|
||||
outputs = outputs.strip()
|
||||
if outputs.endswith(stop_str):
|
||||
outputs = outputs[:-len(stop_str)]
|
||||
outputs = outputs.strip()
|
||||
print(outputs)
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--image-file", type=str, required=True)
|
||||
parser.add_argument("--query", type=str, required=True)
|
||||
parser.add_argument("--conv-mode", type=str, default=None)
|
||||
args = parser.parse_args()
|
||||
|
||||
eval_model(args)
|
||||
@@ -1,26 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
from collections import defaultdict
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
base_dir = "vqa/reviews/coco2014_val80"
|
||||
review_files = [x for x in os.listdir(base_dir) if x.endswith('.jsonl') and x.startswith('gpt4_text')]
|
||||
|
||||
for review_file in sorted(review_files):
|
||||
config = review_file.replace('gpt4_text_', '').replace('.jsonl', '')
|
||||
scores = defaultdict(list)
|
||||
print(f'GPT-4 vs. {config}')
|
||||
with open(os.path.join(base_dir, review_file)) as f:
|
||||
for review_str in f:
|
||||
review = json.loads(review_str)
|
||||
scores[review['category']].append(review['tuple'])
|
||||
scores['all'].append(review['tuple'])
|
||||
for k, v in scores.items():
|
||||
stats = np.asarray(v).mean(0).tolist()
|
||||
stats = [round(x, 3) for x in stats]
|
||||
print(k, stats, round(stats[1]/stats[0]*100, 1))
|
||||
print('=================================')
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
from .llava import LlavaLlamaForCausalLM, LlavaConfig
|
||||
from .llava_mpt import LlavaMPTForCausalLM, LlavaMPTConfig
|
||||
@@ -1,48 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.model.apply_delta --base ~/model_weights/llama-7b --target ~/model_weights/vicuna-7b --delta lmsys/vicuna-7b-delta
|
||||
"""
|
||||
import argparse
|
||||
|
||||
import torch
|
||||
from tqdm import tqdm
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
from llava import LlavaLlamaForCausalLM
|
||||
|
||||
|
||||
def apply_delta(base_model_path, target_model_path, delta_path):
|
||||
print("Loading base model")
|
||||
base = AutoModelForCausalLM.from_pretrained(
|
||||
base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
|
||||
print("Loading delta")
|
||||
delta = LlavaLlamaForCausalLM.from_pretrained(delta_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
delta_tokenizer = AutoTokenizer.from_pretrained(delta_path)
|
||||
|
||||
print("Applying delta")
|
||||
for name, param in tqdm(delta.state_dict().items(), desc="Applying delta"):
|
||||
if name not in base.state_dict():
|
||||
assert name in ['model.mm_projector.weight', 'model.mm_projector.bias'], f'{name} not in base model'
|
||||
continue
|
||||
if param.data.shape == base.state_dict()[name].shape:
|
||||
param.data += base.state_dict()[name]
|
||||
else:
|
||||
assert name in ['model.embed_tokens.weight', 'lm_head.weight'], \
|
||||
f'{name} dimension mismatch: {param.data.shape} vs {base.state_dict()[name].shape}'
|
||||
bparam = base.state_dict()[name]
|
||||
param.data[:bparam.shape[0], :bparam.shape[1]] += bparam
|
||||
|
||||
print("Saving target model")
|
||||
delta.save_pretrained(target_model_path)
|
||||
delta_tokenizer.save_pretrained(target_model_path)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-model-path", type=str, required=True)
|
||||
parser.add_argument("--target-model-path", type=str, required=True)
|
||||
parser.add_argument("--delta-path", type=str, required=True)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
apply_delta(args.base_model_path, args.target_model_path, args.delta_path)
|
||||
@@ -1,29 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m llava.model.consolidate --src ~/model_weights/llava-7b --dst ~/model_weights/llava-7b_consolidate
|
||||
"""
|
||||
import argparse
|
||||
|
||||
import torch
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
from llava.model import *
|
||||
from llava.model.utils import auto_upgrade
|
||||
|
||||
|
||||
def consolidate_ckpt(src_path, dst_path):
|
||||
print("Loading model")
|
||||
auto_upgrade(src_path)
|
||||
src_model = AutoModelForCausalLM.from_pretrained(src_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
src_tokenizer = AutoTokenizer.from_pretrained(src_path)
|
||||
src_model.save_pretrained(dst_path)
|
||||
src_tokenizer.save_pretrained(dst_path)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--src", type=str, required=True)
|
||||
parser.add_argument("--dst", type=str, required=True)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
consolidate_ckpt(args.src, args.dst)
|
||||
@@ -1,330 +0,0 @@
|
||||
# Copyright 2023 Haotian Liu
|
||||
#
|
||||
# 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 typing import List, Optional, Tuple, Union
|
||||
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
from torch.nn import CrossEntropyLoss
|
||||
|
||||
from transformers import AutoConfig, AutoModelForCausalLM, \
|
||||
LlamaConfig, LlamaModel, LlamaForCausalLM, \
|
||||
CLIPVisionModel, CLIPImageProcessor
|
||||
|
||||
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
class LlavaConfig(LlamaConfig):
|
||||
model_type = "llava"
|
||||
|
||||
|
||||
class LlavaLlamaModel(LlamaModel):
|
||||
config_class = LlavaConfig
|
||||
|
||||
def __init__(self, config: LlamaConfig, mm_vision_tower=None, mm_hidden_size=None):
|
||||
super(LlavaLlamaModel, self).__init__(config)
|
||||
|
||||
if hasattr(config, "mm_vision_tower"):
|
||||
# HACK: for FSDP
|
||||
self.vision_tower = [CLIPVisionModel.from_pretrained(config.mm_vision_tower)]
|
||||
# self.vision_tower = CLIPVisionModel.from_pretrained(config.mm_vision_tower)
|
||||
|
||||
if hasattr(config, "use_mm_proj"):
|
||||
self.mm_projector = nn.Linear(config.mm_hidden_size, config.hidden_size)
|
||||
|
||||
def initialize_vision_modules(self, vision_tower, mm_vision_select_layer,
|
||||
pretrain_mm_mlp_adapter=None, tune_mm_mlp_adapter=False):
|
||||
self.config.mm_vision_tower = vision_tower
|
||||
|
||||
image_processor = CLIPImageProcessor.from_pretrained(vision_tower)
|
||||
|
||||
if not hasattr(self, 'vision_tower'):
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower)
|
||||
else:
|
||||
vision_tower = self.vision_tower[0]
|
||||
vision_tower.requires_grad_(False)
|
||||
vision_tower = vision_tower.to(torch.float16)
|
||||
self.vision_tower = [vision_tower]
|
||||
|
||||
vision_config = vision_tower.config
|
||||
num_patches = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
self.config.use_mm_proj = True
|
||||
self.config.mm_hidden_size = vision_config.hidden_size
|
||||
self.config.mm_vision_select_layer = mm_vision_select_layer
|
||||
|
||||
if not hasattr(self, 'mm_projector'):
|
||||
self.mm_projector = nn.Linear(vision_config.hidden_size, self.config.hidden_size)
|
||||
|
||||
if pretrain_mm_mlp_adapter is not None:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
self.mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items()})
|
||||
|
||||
return dict(
|
||||
image_processor=image_processor,
|
||||
image_token_len=num_patches,
|
||||
vision_config=vision_config
|
||||
)
|
||||
|
||||
def forward(
|
||||
self,
|
||||
input_ids: torch.LongTensor = None,
|
||||
attention_mask: Optional[torch.Tensor] = None,
|
||||
past_key_values: Optional[List[torch.FloatTensor]] = None,
|
||||
inputs_embeds: Optional[torch.FloatTensor] = None,
|
||||
use_cache: Optional[bool] = None,
|
||||
output_attentions: Optional[bool] = None,
|
||||
output_hidden_states: Optional[bool] = None,
|
||||
images: Optional[torch.FloatTensor] = None,
|
||||
return_dict: Optional[bool] = None,
|
||||
) -> Union[Tuple, BaseModelOutputWithPast]:
|
||||
|
||||
# HACK: replace back original embeddings for LLaVA pretraining
|
||||
orig_embeds_params = getattr(self, 'orig_embeds_params', None)
|
||||
# if orig_embeds_params is not None:
|
||||
# orig_embeds_params = orig_embeds_params[0]
|
||||
# with torch.no_grad():
|
||||
# self.get_input_embeddings().weight.data[:-2] = orig_embeds_params[:-2].data
|
||||
|
||||
if inputs_embeds is None:
|
||||
inputs_embeds = self.embed_tokens(input_ids)
|
||||
|
||||
vision_tower = getattr(self, 'vision_tower', None)
|
||||
if vision_tower is not None and (input_ids.shape[1] != 1 or self.training) and images is not None:
|
||||
# TODO: this is a modified multimodal LLM -- Haotian Liu
|
||||
vision_tower = vision_tower[0] # HACK: for FSDP
|
||||
with torch.no_grad():
|
||||
if type(images) is list:
|
||||
# variable length images
|
||||
image_features = []
|
||||
for image in images:
|
||||
image_forward_out = vision_tower(image.unsqueeze(0), output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_out.hidden_states[select_hidden_state_layer]
|
||||
image_feature = select_hidden_state[:, 1:]
|
||||
image_features.append(image_feature)
|
||||
else:
|
||||
image_forward_outs = vision_tower(images, output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_outs.hidden_states[select_hidden_state_layer]
|
||||
image_features = select_hidden_state[:, 1:]
|
||||
if type(images) is list:
|
||||
image_features = [self.mm_projector(image_feature)[0] for image_feature in image_features]
|
||||
else:
|
||||
image_features = self.mm_projector(image_features)
|
||||
dummy_image_features = torch.zeros(256, 1024, device=inputs_embeds.device, dtype=inputs_embeds.dtype)
|
||||
dummy_image_features = self.mm_projector(dummy_image_features)
|
||||
|
||||
new_input_embeds = []
|
||||
cur_image_idx = 0
|
||||
for cur_input_ids, cur_input_embeds in zip(input_ids, inputs_embeds):
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() == 0:
|
||||
# multimodal LLM, but the current sample is not multimodal
|
||||
cur_input_embeds = cur_input_embeds + (0. * dummy_image_features).sum()
|
||||
new_input_embeds.append(cur_input_embeds)
|
||||
cur_image_idx += 1
|
||||
continue
|
||||
if vision_tower.config.use_im_start_end:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_start_token).sum() != (cur_input_ids == vision_tower.config.im_end_token).sum():
|
||||
raise ValueError("The number of image start tokens and image end tokens should be the same.")
|
||||
image_start_tokens = torch.where(cur_input_ids == vision_tower.config.im_start_token)[0]
|
||||
for image_start_token_pos in image_start_tokens:
|
||||
cur_image_features = image_features[cur_image_idx].to(device=cur_input_embeds.device)
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if cur_input_ids[image_start_token_pos + num_patches + 1] != vision_tower.config.im_end_token:
|
||||
raise ValueError("The image end token should follow the image start token.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos].detach(), cur_input_embeds[image_start_token_pos:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:image_start_token_pos + num_patches + 2], cur_input_embeds[image_start_token_pos + num_patches + 2:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:]), dim=0)
|
||||
cur_image_idx += 1
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
else:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() != num_patches:
|
||||
raise ValueError("The number of image patch tokens should be the same as the number of image patches.")
|
||||
masked_indices = torch.where(cur_input_ids == vision_tower.config.im_patch_token)[0]
|
||||
mask_index_start = masked_indices[0]
|
||||
if (masked_indices != torch.arange(mask_index_start, mask_index_start+num_patches, device=masked_indices.device, dtype=masked_indices.dtype)).any():
|
||||
raise ValueError("The image patch tokens should be consecutive.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start].detach(), cur_image_features, cur_input_embeds[mask_index_start+num_patches:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start], cur_image_features, cur_input_embeds[mask_index_start+num_patches:]), dim=0)
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
cur_image_idx += 1
|
||||
inputs_embeds = torch.stack(new_input_embeds, dim=0)
|
||||
|
||||
return super(LlavaLlamaModel, self).forward(
|
||||
input_ids=None, attention_mask=attention_mask, past_key_values=past_key_values,
|
||||
inputs_embeds=inputs_embeds, use_cache=use_cache,
|
||||
output_attentions=output_attentions, output_hidden_states=output_hidden_states,
|
||||
return_dict=return_dict
|
||||
)
|
||||
|
||||
|
||||
class LlavaLlamaForCausalLM(LlamaForCausalLM):
|
||||
config_class = LlavaConfig
|
||||
|
||||
def __init__(self, config):
|
||||
super(LlamaForCausalLM, self).__init__(config)
|
||||
self.model = LlavaLlamaModel(config)
|
||||
|
||||
self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
|
||||
|
||||
# Initialize weights and apply final processing
|
||||
self.post_init()
|
||||
|
||||
def get_model(self):
|
||||
return self.model
|
||||
|
||||
def forward(
|
||||
self,
|
||||
input_ids: torch.LongTensor = None,
|
||||
attention_mask: Optional[torch.Tensor] = None,
|
||||
past_key_values: Optional[List[torch.FloatTensor]] = None,
|
||||
inputs_embeds: Optional[torch.FloatTensor] = None,
|
||||
labels: Optional[torch.LongTensor] = None,
|
||||
use_cache: Optional[bool] = None,
|
||||
output_attentions: Optional[bool] = None,
|
||||
output_hidden_states: Optional[bool] = None,
|
||||
images: Optional[torch.FloatTensor] = None,
|
||||
return_dict: Optional[bool] = None,
|
||||
) -> Union[Tuple, CausalLMOutputWithPast]:
|
||||
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
|
||||
|
||||
# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
|
||||
outputs = self.model(
|
||||
input_ids=input_ids,
|
||||
attention_mask=attention_mask,
|
||||
past_key_values=past_key_values,
|
||||
inputs_embeds=inputs_embeds,
|
||||
use_cache=use_cache,
|
||||
output_attentions=output_attentions,
|
||||
output_hidden_states=output_hidden_states,
|
||||
return_dict=return_dict,
|
||||
images=images
|
||||
)
|
||||
|
||||
hidden_states = outputs[0]
|
||||
logits = self.lm_head(hidden_states)
|
||||
|
||||
loss = None
|
||||
if labels is not None:
|
||||
# Shift so that tokens < n predict n
|
||||
shift_logits = logits[..., :-1, :].contiguous()
|
||||
shift_labels = labels[..., 1:].contiguous()
|
||||
# Flatten the tokens
|
||||
loss_fct = CrossEntropyLoss()
|
||||
shift_logits = shift_logits.view(-1, self.config.vocab_size)
|
||||
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)
|
||||
|
||||
if not return_dict:
|
||||
output = (logits,) + outputs[1:]
|
||||
return (loss,) + output if loss is not None else output
|
||||
|
||||
return CausalLMOutputWithPast(
|
||||
loss=loss,
|
||||
logits=logits,
|
||||
past_key_values=outputs.past_key_values,
|
||||
hidden_states=outputs.hidden_states,
|
||||
attentions=outputs.attentions,
|
||||
)
|
||||
|
||||
def prepare_inputs_for_generation(
|
||||
self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
|
||||
):
|
||||
if past_key_values:
|
||||
input_ids = input_ids[:, -1:]
|
||||
|
||||
# if `inputs_embeds` are passed, we only want to use them in the 1st generation step
|
||||
if inputs_embeds is not None and past_key_values is None:
|
||||
model_inputs = {"inputs_embeds": inputs_embeds}
|
||||
else:
|
||||
model_inputs = {"input_ids": input_ids}
|
||||
|
||||
model_inputs.update(
|
||||
{
|
||||
"past_key_values": past_key_values,
|
||||
"use_cache": kwargs.get("use_cache"),
|
||||
"attention_mask": attention_mask,
|
||||
"images": kwargs.get("images", None),
|
||||
}
|
||||
)
|
||||
return model_inputs
|
||||
|
||||
def initialize_vision_tokenizer(self, mm_use_im_start_end, tokenizer, device,
|
||||
tune_mm_mlp_adapter=False, pretrain_mm_mlp_adapter=None):
|
||||
vision_config = self.get_model().vision_tower[0].config
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
|
||||
if mm_use_im_start_end:
|
||||
num_new_tokens = tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
if num_new_tokens > 0:
|
||||
input_embeddings = self.get_input_embeddings().weight.data
|
||||
output_embeddings = self.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
|
||||
|
||||
if tune_mm_mlp_adapter:
|
||||
self.get_model().orig_embeds_params = [self.get_input_embeddings().weight.data.clone().to(device=device)]
|
||||
for p in self.get_input_embeddings().parameters():
|
||||
p.requires_grad = True
|
||||
for p in self.get_output_embeddings().parameters():
|
||||
p.requires_grad = False
|
||||
|
||||
if pretrain_mm_mlp_adapter:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
embed_tokens_weight = mm_projector_weights['model.embed_tokens.weight']
|
||||
assert num_new_tokens == 2
|
||||
if input_embeddings.shape == embed_tokens_weight.shape:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
|
||||
elif embed_tokens_weight.shape[0] == num_new_tokens:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight
|
||||
else:
|
||||
raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
|
||||
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
|
||||
AutoConfig.register("llava", LlavaConfig)
|
||||
AutoModelForCausalLM.register(LlavaConfig, LlavaLlamaForCausalLM)
|
||||
@@ -1,281 +0,0 @@
|
||||
# Copyright 2023 Haotian Liu
|
||||
#
|
||||
# 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 typing import List, Optional, Tuple, Union
|
||||
import warnings
|
||||
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
from torch.nn import CrossEntropyLoss
|
||||
|
||||
import math
|
||||
|
||||
from transformers import AutoConfig, AutoModelForCausalLM, \
|
||||
CLIPVisionModel, CLIPImageProcessor
|
||||
|
||||
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
|
||||
|
||||
from .mpt.modeling_mpt import MPTConfig, MPTForCausalLM, MPTModel
|
||||
|
||||
|
||||
DEFAULT_IMAGE_TOKEN = "<image>"
|
||||
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
|
||||
DEFAULT_IM_START_TOKEN = "<im_start>"
|
||||
DEFAULT_IM_END_TOKEN = "<im_end>"
|
||||
|
||||
|
||||
class LlavaMPTConfig(MPTConfig):
|
||||
model_type = "llava_mpt"
|
||||
|
||||
|
||||
class LlavaMPTModel(MPTModel):
|
||||
config_class = LlavaMPTConfig
|
||||
|
||||
def __init__(self, config: MPTConfig, mm_vision_tower=None, mm_hidden_size=None):
|
||||
super(LlavaMPTModel, self).__init__(config)
|
||||
|
||||
if hasattr(config, "mm_vision_tower"):
|
||||
# HACK: for FSDP
|
||||
self.vision_tower = [CLIPVisionModel.from_pretrained(config.mm_vision_tower)]
|
||||
# self.vision_tower = CLIPVisionModel.from_pretrained(config.mm_vision_tower)
|
||||
|
||||
if hasattr(config, "use_mm_proj"):
|
||||
self.mm_projector = nn.Linear(config.mm_hidden_size, config.d_model)
|
||||
|
||||
def initialize_vision_modules(self, vision_tower, mm_vision_select_layer,
|
||||
pretrain_mm_mlp_adapter=None, tune_mm_mlp_adapter=False):
|
||||
self.config.mm_vision_tower = vision_tower
|
||||
|
||||
image_processor = CLIPImageProcessor.from_pretrained(vision_tower)
|
||||
|
||||
if not hasattr(self, 'vision_tower'):
|
||||
vision_tower = CLIPVisionModel.from_pretrained(vision_tower)
|
||||
else:
|
||||
vision_tower = self.vision_tower[0]
|
||||
vision_tower.requires_grad_(False)
|
||||
vision_tower = vision_tower.to(torch.float16)
|
||||
self.vision_tower = [vision_tower]
|
||||
|
||||
vision_config = vision_tower.config
|
||||
num_patches = (vision_config.image_size // vision_config.patch_size) ** 2
|
||||
|
||||
self.config.use_mm_proj = True
|
||||
self.config.mm_hidden_size = vision_config.hidden_size
|
||||
self.config.mm_vision_select_layer = mm_vision_select_layer
|
||||
|
||||
if not hasattr(self, 'mm_projector'):
|
||||
self.mm_projector = nn.Linear(vision_config.hidden_size, self.config.d_model)
|
||||
|
||||
if pretrain_mm_mlp_adapter is not None:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
self.mm_projector.load_state_dict({k.split('.')[-1]: v for k, v in mm_projector_weights.items() if 'mm_projector' in k})
|
||||
|
||||
return dict(
|
||||
image_processor=image_processor,
|
||||
image_token_len=num_patches,
|
||||
vision_config=vision_config
|
||||
)
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None, images=None):
|
||||
|
||||
# HACK: replace back original embeddings for LLaVA pretraining
|
||||
orig_embeds_params = getattr(self, 'orig_embeds_params', None)
|
||||
# if orig_embeds_params is not None:
|
||||
# orig_embeds_params = orig_embeds_params[0]
|
||||
# with torch.no_grad():
|
||||
# self.get_input_embeddings().weight.data[:-2] = orig_embeds_params[:-2].data
|
||||
|
||||
inputs_embeds = self.wte(input_ids)
|
||||
|
||||
vision_tower = getattr(self, 'vision_tower', None)
|
||||
if vision_tower is not None and (input_ids.shape[1] != 1 or self.training) and images is not None:
|
||||
# TODO: this is a modified multimodal LLM -- Haotian Liu
|
||||
vision_tower = vision_tower[0] # HACK: for FSDP
|
||||
with torch.no_grad():
|
||||
if type(images) is list:
|
||||
# variable length images
|
||||
image_features = []
|
||||
for image in images:
|
||||
image_forward_out = vision_tower(image.unsqueeze(0), output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_out.hidden_states[select_hidden_state_layer]
|
||||
image_feature = select_hidden_state[:, 1:]
|
||||
image_features.append(image_feature)
|
||||
else:
|
||||
image_forward_outs = vision_tower(images, output_hidden_states=True)
|
||||
select_hidden_state_layer = getattr(self.config, "mm_vision_select_layer", -1)
|
||||
select_hidden_state = image_forward_outs.hidden_states[select_hidden_state_layer]
|
||||
image_features = select_hidden_state[:, 1:]
|
||||
if type(images) is list:
|
||||
image_features = [self.mm_projector(image_feature)[0] for image_feature in image_features]
|
||||
else:
|
||||
image_features = self.mm_projector(image_features)
|
||||
dummy_image_features = torch.zeros(256, 1024, device=inputs_embeds.device, dtype=inputs_embeds.dtype)
|
||||
dummy_image_features = self.mm_projector(dummy_image_features)
|
||||
|
||||
new_input_embeds = []
|
||||
cur_image_idx = 0
|
||||
for cur_input_ids, cur_input_embeds in zip(input_ids, inputs_embeds):
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() == 0:
|
||||
# multimodal LLM, but the current sample is not multimodal
|
||||
cur_input_embeds = cur_input_embeds + (0. * dummy_image_features).sum()
|
||||
new_input_embeds.append(cur_input_embeds)
|
||||
continue
|
||||
if vision_tower.config.use_im_start_end:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_start_token).sum() != (cur_input_ids == vision_tower.config.im_end_token).sum():
|
||||
raise ValueError("The number of image start tokens and image end tokens should be the same.")
|
||||
image_start_tokens = torch.where(cur_input_ids == vision_tower.config.im_start_token)[0]
|
||||
for image_start_token_pos in image_start_tokens:
|
||||
cur_image_features = image_features[cur_image_idx].to(device=cur_input_embeds.device)
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if cur_input_ids[image_start_token_pos + num_patches + 1] != vision_tower.config.im_end_token:
|
||||
raise ValueError("The image end token should follow the image start token.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos].detach(), cur_input_embeds[image_start_token_pos:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:image_start_token_pos + num_patches + 2], cur_input_embeds[image_start_token_pos + num_patches + 2:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:image_start_token_pos+1], cur_image_features, cur_input_embeds[image_start_token_pos + num_patches + 1:]), dim=0)
|
||||
cur_image_idx += 1
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
else:
|
||||
cur_image_features = image_features[cur_image_idx]
|
||||
num_patches = cur_image_features.shape[0]
|
||||
if (cur_input_ids == vision_tower.config.im_patch_token).sum() != num_patches:
|
||||
raise ValueError("The number of image patch tokens should be the same as the number of image patches.")
|
||||
masked_indices = torch.where(cur_input_ids == vision_tower.config.im_patch_token)[0]
|
||||
mask_index_start = masked_indices[0]
|
||||
if (masked_indices != torch.arange(mask_index_start, mask_index_start+num_patches, device=masked_indices.device, dtype=masked_indices.dtype)).any():
|
||||
raise ValueError("The image patch tokens should be consecutive.")
|
||||
if orig_embeds_params is not None:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start].detach(), cur_image_features, cur_input_embeds[mask_index_start+num_patches:].detach()), dim=0)
|
||||
else:
|
||||
cur_new_input_embeds = torch.cat((cur_input_embeds[:mask_index_start], cur_image_features, cur_input_embeds[mask_index_start+num_patches:]), dim=0)
|
||||
new_input_embeds.append(cur_new_input_embeds)
|
||||
inputs_embeds = torch.stack(new_input_embeds, dim=0)
|
||||
|
||||
return super(LlavaMPTModel, self).forward(input_ids=None, past_key_values=past_key_values, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id, return_dict=return_dict, output_attentions=output_attentions, output_hidden_states=output_hidden_states, use_cache=use_cache, tok_emb=inputs_embeds)
|
||||
|
||||
|
||||
class LlavaMPTForCausalLM(MPTForCausalLM):
|
||||
config_class = LlavaMPTConfig
|
||||
supports_gradient_checkpointing = True
|
||||
|
||||
def __init__(self, config):
|
||||
super(MPTForCausalLM, self).__init__(config)
|
||||
|
||||
if not config.tie_word_embeddings:
|
||||
raise ValueError('MPTForCausalLM only supports tied word embeddings')
|
||||
self.transformer = LlavaMPTModel(config)
|
||||
self.logit_scale = None
|
||||
if config.logit_scale is not None:
|
||||
logit_scale = config.logit_scale
|
||||
if isinstance(logit_scale, str):
|
||||
if logit_scale == 'inv_sqrt_d_model':
|
||||
logit_scale = 1 / math.sqrt(config.d_model)
|
||||
else:
|
||||
raise ValueError(f"logit_scale={logit_scale!r} is not recognized as an option; use numeric value or 'inv_sqrt_d_model'.")
|
||||
self.logit_scale = logit_scale
|
||||
|
||||
def get_model(self):
|
||||
return self.transformer
|
||||
|
||||
def _set_gradient_checkpointing(self, module, value=False):
|
||||
if isinstance(module, LlavaMPTModel):
|
||||
module.gradient_checkpointing = value
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, labels: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None, images=None):
|
||||
return_dict = return_dict if return_dict is not None else self.config.return_dict
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
outputs = self.transformer(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id, return_dict=return_dict, output_attentions=output_attentions, output_hidden_states=output_hidden_states, use_cache=use_cache, images=images)
|
||||
logits = F.linear(outputs.last_hidden_state, self.transformer.wte.weight)
|
||||
if self.logit_scale is not None:
|
||||
if self.logit_scale == 0:
|
||||
warnings.warn(f'Multiplying logits by self.logit_scale={self.logit_scale!r}. This will produce uniform (uninformative) outputs.')
|
||||
logits *= self.logit_scale
|
||||
loss = None
|
||||
if labels is not None:
|
||||
labels = torch.roll(labels, shifts=-1)
|
||||
labels[:, -1] = -100
|
||||
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), labels.to(logits.device).view(-1))
|
||||
return CausalLMOutputWithPast(loss=loss, logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states)
|
||||
|
||||
def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
|
||||
if inputs_embeds is not None:
|
||||
raise NotImplementedError('inputs_embeds is not implemented for MPT yet')
|
||||
attention_mask = kwargs['attention_mask'].bool()
|
||||
if attention_mask[:, -1].sum() != attention_mask.shape[0]:
|
||||
raise NotImplementedError('MPT does not support generation with right padding.')
|
||||
if self.transformer.attn_uses_sequence_id and self.training:
|
||||
sequence_id = torch.zeros_like(input_ids[:1])
|
||||
else:
|
||||
sequence_id = None
|
||||
if past_key_values is not None:
|
||||
input_ids = input_ids[:, -1].unsqueeze(-1)
|
||||
if self.transformer.prefix_lm:
|
||||
prefix_mask = torch.ones_like(attention_mask)
|
||||
if kwargs.get('use_cache') == False:
|
||||
raise NotImplementedError('MPT with prefix_lm=True does not support use_cache=False.')
|
||||
else:
|
||||
prefix_mask = None
|
||||
return {'input_ids': input_ids, 'attention_mask': attention_mask, 'prefix_mask': prefix_mask, 'sequence_id': sequence_id, 'past_key_values': past_key_values, 'use_cache': kwargs.get('use_cache', True), "images": kwargs.get("images", None)}
|
||||
|
||||
def initialize_vision_tokenizer(self, mm_use_im_start_end, tokenizer, device,
|
||||
tune_mm_mlp_adapter=False, pretrain_mm_mlp_adapter=None):
|
||||
vision_config = self.get_model().vision_tower[0].config
|
||||
vision_config.use_im_start_end = mm_use_im_start_end
|
||||
tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
|
||||
if mm_use_im_start_end:
|
||||
num_new_tokens = tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
|
||||
self.resize_token_embeddings(len(tokenizer))
|
||||
vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN])
|
||||
|
||||
if num_new_tokens > 0:
|
||||
input_embeddings = self.get_input_embeddings().weight.data
|
||||
output_embeddings = self.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
|
||||
|
||||
if tune_mm_mlp_adapter:
|
||||
self.get_model().orig_embeds_params = [self.get_input_embeddings().weight.data.clone().to(device=device)]
|
||||
for p in self.get_input_embeddings().parameters():
|
||||
p.requires_grad = True
|
||||
for p in self.get_output_embeddings().parameters():
|
||||
p.requires_grad = False
|
||||
|
||||
if pretrain_mm_mlp_adapter:
|
||||
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
|
||||
embed_tokens_weight = mm_projector_weights['transformer.wte.weight']
|
||||
assert num_new_tokens == 2
|
||||
if input_embeddings.shape == embed_tokens_weight.shape:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
|
||||
elif embed_tokens_weight.shape[0] == num_new_tokens:
|
||||
input_embeddings[-num_new_tokens:] = embed_tokens_weight
|
||||
else:
|
||||
raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
|
||||
|
||||
vision_config.im_patch_token = tokenizer.convert_tokens_to_ids([DEFAULT_IMAGE_PATCH_TOKEN])[0]
|
||||
|
||||
AutoConfig.register("llava_mpt", LlavaMPTConfig)
|
||||
AutoModelForCausalLM.register(LlavaMPTConfig, LlavaMPTForCausalLM)
|
||||
@@ -1,52 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m llava.model.make_delta --base ~/model_weights/llama-7b --target ~/model_weights/llava-7b --delta ~/model_weights/llava-7b-delta --hub-repo-id liuhaotian/llava-7b-delta
|
||||
"""
|
||||
import argparse
|
||||
|
||||
import torch
|
||||
from tqdm import tqdm
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
from llava.model.utils import auto_upgrade
|
||||
|
||||
|
||||
def make_delta(base_model_path, target_model_path, delta_path, hub_repo_id):
|
||||
print("Loading base model")
|
||||
base = AutoModelForCausalLM.from_pretrained(
|
||||
base_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
|
||||
print("Loading target model")
|
||||
auto_upgrade(target_model_path)
|
||||
target = AutoModelForCausalLM.from_pretrained(target_model_path, torch_dtype=torch.float16, low_cpu_mem_usage=True)
|
||||
|
||||
print("Calculating delta")
|
||||
for name, param in tqdm(target.state_dict().items(), desc="Calculating delta"):
|
||||
if name not in base.state_dict():
|
||||
assert name in ['model.mm_projector.weight', 'model.mm_projector.bias'], f'{name} not in base model'
|
||||
continue
|
||||
if param.data.shape == base.state_dict()[name].shape:
|
||||
param.data -= base.state_dict()[name]
|
||||
else:
|
||||
assert name in ['model.embed_tokens.weight', 'lm_head.weight'], f'{name} dimension mismatch: {param.data.shape} vs {base.state_dict()[name].shape}'
|
||||
bparam = base.state_dict()[name]
|
||||
param.data[:bparam.shape[0], :bparam.shape[1]] -= bparam
|
||||
|
||||
print("Saving delta")
|
||||
if hub_repo_id:
|
||||
kwargs = {"push_to_hub": True, "repo_id": hub_repo_id}
|
||||
else:
|
||||
kwargs = {}
|
||||
target.save_pretrained(delta_path, **kwargs)
|
||||
target_tokenizer = AutoTokenizer.from_pretrained(target_model_path)
|
||||
target_tokenizer.save_pretrained(delta_path, **kwargs)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-model-path", type=str, required=True)
|
||||
parser.add_argument("--target-model-path", type=str, required=True)
|
||||
parser.add_argument("--delta-path", type=str, required=True)
|
||||
parser.add_argument("--hub-repo-id", type=str, default=None)
|
||||
args = parser.parse_args()
|
||||
|
||||
make_delta(args.base_model_path, args.target_model_path, args.delta_path, args.hub_repo_id)
|
||||
@@ -1,41 +0,0 @@
|
||||
from typing import Union
|
||||
from transformers import AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast
|
||||
Tokenizer = Union[PreTrainedTokenizer, PreTrainedTokenizerFast]
|
||||
NUM_SENTINEL_TOKENS: int = 100
|
||||
|
||||
def adapt_tokenizer_for_denoising(tokenizer: Tokenizer):
|
||||
"""Adds sentinel tokens and padding token (if missing).
|
||||
|
||||
Expands the tokenizer vocabulary to include sentinel tokens
|
||||
used in mixture-of-denoiser tasks as well as a padding token.
|
||||
|
||||
All added tokens are added as special tokens. No tokens are
|
||||
added if sentinel tokens and padding token already exist.
|
||||
"""
|
||||
sentinels_to_add = [f'<extra_id_{i}>' for i in range(NUM_SENTINEL_TOKENS)]
|
||||
tokenizer.add_tokens(sentinels_to_add, special_tokens=True)
|
||||
if tokenizer.pad_token is None:
|
||||
tokenizer.add_tokens('<pad>', special_tokens=True)
|
||||
tokenizer.pad_token = '<pad>'
|
||||
assert tokenizer.pad_token_id is not None
|
||||
sentinels = ''.join([f'<extra_id_{i}>' for i in range(NUM_SENTINEL_TOKENS)])
|
||||
_sentinel_token_ids = tokenizer(sentinels, add_special_tokens=False).input_ids
|
||||
tokenizer.sentinel_token_ids = _sentinel_token_ids
|
||||
|
||||
class AutoTokenizerForMOD(AutoTokenizer):
|
||||
"""AutoTokenizer + Adaptation for MOD.
|
||||
|
||||
A simple wrapper around AutoTokenizer to make instantiating
|
||||
an MOD-adapted tokenizer a bit easier.
|
||||
|
||||
MOD-adapted tokenizers have sentinel tokens (e.g., <extra_id_0>),
|
||||
a padding token, and a property to get the token ids of the
|
||||
sentinel tokens.
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def from_pretrained(cls, *args, **kwargs):
|
||||
"""See `AutoTokenizer.from_pretrained` docstring."""
|
||||
tokenizer = super().from_pretrained(*args, **kwargs)
|
||||
adapt_tokenizer_for_denoising(tokenizer)
|
||||
return tokenizer
|
||||
@@ -1,276 +0,0 @@
|
||||
"""Attention layers."""
|
||||
import math
|
||||
import warnings
|
||||
from typing import Optional
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
from einops import rearrange
|
||||
from torch import nn
|
||||
from .norm import LPLayerNorm
|
||||
|
||||
def _reset_is_causal(num_query_tokens: int, num_key_tokens: int, original_is_causal: bool):
|
||||
if original_is_causal and num_query_tokens != num_key_tokens:
|
||||
if num_query_tokens != 1:
|
||||
raise NotImplementedError('MPT does not support query and key with different number of tokens, unless number of query tokens is 1.')
|
||||
else:
|
||||
return False
|
||||
return original_is_causal
|
||||
|
||||
def scaled_multihead_dot_product_attention(query, key, value, n_heads, softmax_scale=None, attn_bias=None, key_padding_mask=None, is_causal=False, dropout_p=0.0, training=False, needs_weights=False, multiquery=False):
|
||||
q = rearrange(query, 'b s (h d) -> b h s d', h=n_heads)
|
||||
k = rearrange(key, 'b s (h d) -> b h d s', h=1 if multiquery else n_heads)
|
||||
v = rearrange(value, 'b s (h d) -> b h s d', h=1 if multiquery else n_heads)
|
||||
min_val = torch.finfo(q.dtype).min
|
||||
(b, _, s_q, d) = q.shape
|
||||
s_k = k.size(-1)
|
||||
if softmax_scale is None:
|
||||
softmax_scale = 1 / math.sqrt(d)
|
||||
attn_weight = q.matmul(k) * softmax_scale
|
||||
if attn_bias is not None:
|
||||
if attn_bias.size(-1) != 1 and attn_bias.size(-1) != s_k or (attn_bias.size(-2) != 1 and attn_bias.size(-2) != s_q):
|
||||
raise RuntimeError(f'attn_bias (shape: {attn_bias.shape}) is expected to broadcast to shape: {attn_weight.shape}.')
|
||||
attn_weight = attn_weight + attn_bias
|
||||
if key_padding_mask is not None:
|
||||
if attn_bias is not None:
|
||||
warnings.warn('Propogating key_padding_mask to the attention module ' + 'and applying it within the attention module can cause ' + 'unneccessary computation/memory usage. Consider integrating ' + 'into attn_bias once and passing that to each attention ' + 'module instead.')
|
||||
attn_weight = attn_weight.masked_fill(~key_padding_mask.view((b, 1, 1, s_k)), min_val)
|
||||
if is_causal:
|
||||
s = max(s_q, s_k)
|
||||
causal_mask = attn_weight.new_ones(s, s, dtype=torch.float16)
|
||||
causal_mask = causal_mask.tril()
|
||||
causal_mask = causal_mask.to(torch.bool)
|
||||
causal_mask = ~causal_mask
|
||||
causal_mask = causal_mask[-s_q:, -s_k:]
|
||||
attn_weight = attn_weight.masked_fill(causal_mask.view(1, 1, s_q, s_k), min_val)
|
||||
attn_weight = torch.softmax(attn_weight, dim=-1)
|
||||
if dropout_p:
|
||||
attn_weight = torch.nn.functional.dropout(attn_weight, p=dropout_p, training=training, inplace=True)
|
||||
out = attn_weight.matmul(v)
|
||||
out = rearrange(out, 'b h s d -> b s (h d)')
|
||||
if needs_weights:
|
||||
return (out, attn_weight)
|
||||
return (out, None)
|
||||
|
||||
def check_valid_inputs(*tensors, valid_dtypes=[torch.float16, torch.bfloat16]):
|
||||
for tensor in tensors:
|
||||
if tensor.dtype not in valid_dtypes:
|
||||
raise TypeError(f'tensor.dtype={tensor.dtype!r} must be in valid_dtypes={valid_dtypes!r}.')
|
||||
if not tensor.is_cuda:
|
||||
raise TypeError(f'Inputs must be cuda tensors (tensor.is_cuda={tensor.is_cuda!r}).')
|
||||
|
||||
def flash_attn_fn(query, key, value, n_heads, softmax_scale=None, attn_bias=None, key_padding_mask=None, is_causal=False, dropout_p=0.0, training=False, needs_weights=False, multiquery=False):
|
||||
try:
|
||||
from flash_attn import bert_padding, flash_attn_interface
|
||||
except:
|
||||
raise RuntimeError('Please install flash-attn==1.0.3.post0')
|
||||
check_valid_inputs(query, key, value)
|
||||
if attn_bias is not None:
|
||||
raise NotImplementedError(f'attn_bias not implemented for flash attn.')
|
||||
(batch_size, seqlen) = query.shape[:2]
|
||||
if key_padding_mask is None:
|
||||
key_padding_mask = torch.ones_like(key[:, :, 0], dtype=torch.bool)
|
||||
query_padding_mask = key_padding_mask[:, -query.size(1):]
|
||||
(query_unpad, indices_q, cu_seqlens_q, max_seqlen_q) = bert_padding.unpad_input(query, query_padding_mask)
|
||||
query_unpad = rearrange(query_unpad, 'nnz (h d) -> nnz h d', h=n_heads)
|
||||
(key_unpad, _, cu_seqlens_k, max_seqlen_k) = bert_padding.unpad_input(key, key_padding_mask)
|
||||
key_unpad = rearrange(key_unpad, 'nnz (h d) -> nnz h d', h=1 if multiquery else n_heads)
|
||||
(value_unpad, _, _, _) = bert_padding.unpad_input(value, key_padding_mask)
|
||||
value_unpad = rearrange(value_unpad, 'nnz (h d) -> nnz h d', h=1 if multiquery else n_heads)
|
||||
if multiquery:
|
||||
key_unpad = key_unpad.expand(key_unpad.size(0), n_heads, key_unpad.size(-1))
|
||||
value_unpad = value_unpad.expand(value_unpad.size(0), n_heads, value_unpad.size(-1))
|
||||
dropout_p = dropout_p if training else 0.0
|
||||
reset_is_causal = _reset_is_causal(query.size(1), key.size(1), is_causal)
|
||||
output_unpad = flash_attn_interface.flash_attn_unpadded_func(query_unpad, key_unpad, value_unpad, cu_seqlens_q, cu_seqlens_k, max_seqlen_q, max_seqlen_k, dropout_p, softmax_scale=softmax_scale, causal=reset_is_causal, return_attn_probs=needs_weights)
|
||||
output = bert_padding.pad_input(rearrange(output_unpad, 'nnz h d -> nnz (h d)'), indices_q, batch_size, seqlen)
|
||||
return (output, None)
|
||||
|
||||
def triton_flash_attn_fn(query, key, value, n_heads, softmax_scale=None, attn_bias=None, key_padding_mask=None, is_causal=False, dropout_p=0.0, training=False, needs_weights=False, multiquery=False):
|
||||
try:
|
||||
from flash_attn import flash_attn_triton
|
||||
except:
|
||||
raise RuntimeError('Please install flash-attn==1.0.3.post0 and triton==2.0.0.dev20221202')
|
||||
check_valid_inputs(query, key, value)
|
||||
if dropout_p:
|
||||
raise NotImplementedError(f'Dropout not implemented for attn_impl: triton.')
|
||||
if needs_weights:
|
||||
raise NotImplementedError(f'attn_impl: triton cannot return attn weights.')
|
||||
if key_padding_mask is not None:
|
||||
warnings.warn('Propagating key_padding_mask to the attention module ' + 'and applying it within the attention module can cause ' + 'unnecessary computation/memory usage. Consider integrating ' + 'into attn_bias once and passing that to each attention ' + 'module instead.')
|
||||
(b_size, s_k) = key_padding_mask.shape[:2]
|
||||
if attn_bias is None:
|
||||
attn_bias = query.new_zeros(b_size, 1, 1, s_k)
|
||||
attn_bias = attn_bias.masked_fill(~key_padding_mask.view((b_size, 1, 1, s_k)), torch.finfo(query.dtype).min)
|
||||
query = rearrange(query, 'b s (h d) -> b s h d', h=n_heads)
|
||||
key = rearrange(key, 'b s (h d) -> b s h d', h=1 if multiquery else n_heads)
|
||||
value = rearrange(value, 'b s (h d) -> b s h d', h=1 if multiquery else n_heads)
|
||||
if multiquery:
|
||||
key = key.expand(*key.shape[:2], n_heads, key.size(-1))
|
||||
value = value.expand(*value.shape[:2], n_heads, value.size(-1))
|
||||
reset_is_causal = _reset_is_causal(query.size(1), key.size(1), is_causal)
|
||||
attn_output = flash_attn_triton.flash_attn_func(query, key, value, attn_bias, reset_is_causal, softmax_scale)
|
||||
output = attn_output.view(*attn_output.shape[:2], -1)
|
||||
return (output, None)
|
||||
|
||||
class MultiheadAttention(nn.Module):
|
||||
"""Multi-head self attention.
|
||||
|
||||
Using torch or triton attention implemetation enables user to also use
|
||||
additive bias.
|
||||
"""
|
||||
|
||||
def __init__(self, d_model: int, n_heads: int, attn_impl: str='triton', clip_qkv: Optional[float]=None, qk_ln: bool=False, softmax_scale: Optional[float]=None, attn_pdrop: float=0.0, low_precision_layernorm: bool=False, device: Optional[str]=None):
|
||||
super().__init__()
|
||||
self.attn_impl = attn_impl
|
||||
self.clip_qkv = clip_qkv
|
||||
self.qk_ln = qk_ln
|
||||
self.d_model = d_model
|
||||
self.n_heads = n_heads
|
||||
self.softmax_scale = softmax_scale
|
||||
if self.softmax_scale is None:
|
||||
self.softmax_scale = 1 / math.sqrt(self.d_model / self.n_heads)
|
||||
self.attn_dropout_p = attn_pdrop
|
||||
self.Wqkv = nn.Linear(self.d_model, 3 * self.d_model, device=device)
|
||||
fuse_splits = (d_model, 2 * d_model)
|
||||
self.Wqkv._fused = (0, fuse_splits)
|
||||
if self.qk_ln:
|
||||
layernorm_class = LPLayerNorm if low_precision_layernorm else nn.LayerNorm
|
||||
self.q_ln = layernorm_class(self.d_model, device=device)
|
||||
self.k_ln = layernorm_class(self.d_model, device=device)
|
||||
if self.attn_impl == 'flash':
|
||||
self.attn_fn = flash_attn_fn
|
||||
elif self.attn_impl == 'triton':
|
||||
self.attn_fn = triton_flash_attn_fn
|
||||
warnings.warn('While `attn_impl: triton` can be faster than `attn_impl: flash` ' + 'it uses more memory. When training larger models this can trigger ' + 'alloc retries which hurts performance. If encountered, we recommend ' + 'using `attn_impl: flash` if your model does not use `alibi` or `prefix_lm`.')
|
||||
elif self.attn_impl == 'torch':
|
||||
self.attn_fn = scaled_multihead_dot_product_attention
|
||||
if torch.cuda.is_available():
|
||||
warnings.warn('Using `attn_impl: torch`. If your model does not use `alibi` or ' + '`prefix_lm` we recommend using `attn_impl: flash` otherwise ' + 'we recommend using `attn_impl: triton`.')
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
self.out_proj = nn.Linear(self.d_model, self.d_model, device=device)
|
||||
self.out_proj._is_residual = True
|
||||
|
||||
def forward(self, x, past_key_value=None, attn_bias=None, attention_mask=None, is_causal=True, needs_weights=False):
|
||||
qkv = self.Wqkv(x)
|
||||
if self.clip_qkv:
|
||||
qkv.clamp_(min=-self.clip_qkv, max=self.clip_qkv)
|
||||
(query, key, value) = qkv.chunk(3, dim=2)
|
||||
key_padding_mask = attention_mask
|
||||
if self.qk_ln:
|
||||
dtype = query.dtype
|
||||
query = self.q_ln(query).to(dtype)
|
||||
key = self.k_ln(key).to(dtype)
|
||||
if past_key_value is not None:
|
||||
if len(past_key_value) != 0:
|
||||
key = torch.cat([past_key_value[0], key], dim=1)
|
||||
value = torch.cat([past_key_value[1], value], dim=1)
|
||||
past_key_value = (key, value)
|
||||
if attn_bias is not None:
|
||||
attn_bias = attn_bias[:, :, -query.size(1):, -key.size(1):]
|
||||
(context, attn_weights) = self.attn_fn(query, key, value, self.n_heads, softmax_scale=self.softmax_scale, attn_bias=attn_bias, key_padding_mask=key_padding_mask, is_causal=is_causal, dropout_p=self.attn_dropout_p, training=self.training, needs_weights=needs_weights)
|
||||
return (self.out_proj(context), attn_weights, past_key_value)
|
||||
|
||||
class MultiQueryAttention(nn.Module):
|
||||
"""Multi-Query self attention.
|
||||
|
||||
Using torch or triton attention implemetation enables user to also use
|
||||
additive bias.
|
||||
"""
|
||||
|
||||
def __init__(self, d_model: int, n_heads: int, attn_impl: str='triton', clip_qkv: Optional[float]=None, qk_ln: bool=False, softmax_scale: Optional[float]=None, attn_pdrop: float=0.0, low_precision_layernorm: bool=False, device: Optional[str]=None):
|
||||
super().__init__()
|
||||
self.attn_impl = attn_impl
|
||||
self.clip_qkv = clip_qkv
|
||||
self.qk_ln = qk_ln
|
||||
self.d_model = d_model
|
||||
self.n_heads = n_heads
|
||||
self.head_dim = d_model // n_heads
|
||||
self.softmax_scale = softmax_scale
|
||||
if self.softmax_scale is None:
|
||||
self.softmax_scale = 1 / math.sqrt(self.head_dim)
|
||||
self.attn_dropout_p = attn_pdrop
|
||||
self.Wqkv = nn.Linear(d_model, d_model + 2 * self.head_dim, device=device)
|
||||
fuse_splits = (d_model, d_model + self.head_dim)
|
||||
self.Wqkv._fused = (0, fuse_splits)
|
||||
if self.qk_ln:
|
||||
layernorm_class = LPLayerNorm if low_precision_layernorm else nn.LayerNorm
|
||||
self.q_ln = layernorm_class(d_model, device=device)
|
||||
self.k_ln = layernorm_class(self.head_dim, device=device)
|
||||
if self.attn_impl == 'flash':
|
||||
self.attn_fn = flash_attn_fn
|
||||
elif self.attn_impl == 'triton':
|
||||
self.attn_fn = triton_flash_attn_fn
|
||||
warnings.warn('While `attn_impl: triton` can be faster than `attn_impl: flash` ' + 'it uses more memory. When training larger models this can trigger ' + 'alloc retries which hurts performance. If encountered, we recommend ' + 'using `attn_impl: flash` if your model does not use `alibi` or `prefix_lm`.')
|
||||
elif self.attn_impl == 'torch':
|
||||
self.attn_fn = scaled_multihead_dot_product_attention
|
||||
if torch.cuda.is_available():
|
||||
warnings.warn('Using `attn_impl: torch`. If your model does not use `alibi` or ' + '`prefix_lm` we recommend using `attn_impl: flash` otherwise ' + 'we recommend using `attn_impl: triton`.')
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
self.out_proj = nn.Linear(self.d_model, self.d_model, device=device)
|
||||
self.out_proj._is_residual = True
|
||||
|
||||
def forward(self, x, past_key_value=None, attn_bias=None, attention_mask=None, is_causal=True, needs_weights=False):
|
||||
qkv = self.Wqkv(x)
|
||||
if self.clip_qkv:
|
||||
qkv.clamp_(min=-self.clip_qkv, max=self.clip_qkv)
|
||||
(query, key, value) = qkv.split([self.d_model, self.head_dim, self.head_dim], dim=2)
|
||||
key_padding_mask = attention_mask
|
||||
if self.qk_ln:
|
||||
dtype = query.dtype
|
||||
query = self.q_ln(query).to(dtype)
|
||||
key = self.k_ln(key).to(dtype)
|
||||
if past_key_value is not None:
|
||||
if len(past_key_value) != 0:
|
||||
key = torch.cat([past_key_value[0], key], dim=1)
|
||||
value = torch.cat([past_key_value[1], value], dim=1)
|
||||
past_key_value = (key, value)
|
||||
if attn_bias is not None:
|
||||
attn_bias = attn_bias[:, :, -query.size(1):, -key.size(1):]
|
||||
(context, attn_weights) = self.attn_fn(query, key, value, self.n_heads, softmax_scale=self.softmax_scale, attn_bias=attn_bias, key_padding_mask=key_padding_mask, is_causal=is_causal, dropout_p=self.attn_dropout_p, training=self.training, needs_weights=needs_weights, multiquery=True)
|
||||
return (self.out_proj(context), attn_weights, past_key_value)
|
||||
|
||||
def attn_bias_shape(attn_impl, n_heads, seq_len, alibi, prefix_lm, causal, use_sequence_id):
|
||||
if attn_impl == 'flash':
|
||||
return None
|
||||
elif attn_impl in ['torch', 'triton']:
|
||||
if alibi:
|
||||
if (prefix_lm or not causal) or use_sequence_id:
|
||||
return (1, n_heads, seq_len, seq_len)
|
||||
return (1, n_heads, 1, seq_len)
|
||||
elif prefix_lm or use_sequence_id:
|
||||
return (1, 1, seq_len, seq_len)
|
||||
return None
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
|
||||
def build_attn_bias(attn_impl, attn_bias, n_heads, seq_len, causal=False, alibi=False, alibi_bias_max=8):
|
||||
if attn_impl == 'flash':
|
||||
return None
|
||||
elif attn_impl in ['torch', 'triton']:
|
||||
if alibi:
|
||||
(device, dtype) = (attn_bias.device, attn_bias.dtype)
|
||||
attn_bias = attn_bias.add(build_alibi_bias(n_heads, seq_len, full=not causal, alibi_bias_max=alibi_bias_max, device=device, dtype=dtype))
|
||||
return attn_bias
|
||||
else:
|
||||
raise ValueError(f'attn_impl={attn_impl!r} is an invalid setting.')
|
||||
|
||||
def gen_slopes(n_heads, alibi_bias_max=8, device=None):
|
||||
_n_heads = 2 ** math.ceil(math.log2(n_heads))
|
||||
m = torch.arange(1, _n_heads + 1, dtype=torch.float32, device=device)
|
||||
m = m.mul(alibi_bias_max / _n_heads)
|
||||
slopes = 1.0 / torch.pow(2, m)
|
||||
if _n_heads != n_heads:
|
||||
slopes = torch.concat([slopes[1::2], slopes[::2]])[:n_heads]
|
||||
return slopes.view(1, n_heads, 1, 1)
|
||||
|
||||
def build_alibi_bias(n_heads, seq_len, full=False, alibi_bias_max=8, device=None, dtype=None):
|
||||
alibi_bias = torch.arange(1 - seq_len, 1, dtype=torch.int32, device=device).view(1, 1, 1, seq_len)
|
||||
if full:
|
||||
alibi_bias = alibi_bias - torch.arange(1 - seq_len, 1, dtype=torch.int32, device=device).view(1, 1, seq_len, 1)
|
||||
alibi_bias = alibi_bias.abs().mul(-1)
|
||||
slopes = gen_slopes(n_heads, alibi_bias_max, device=device)
|
||||
alibi_bias = alibi_bias * slopes
|
||||
return alibi_bias.to(dtype=dtype)
|
||||
ATTN_CLASS_REGISTRY = {'multihead_attention': MultiheadAttention, 'multiquery_attention': MultiQueryAttention}
|
||||
@@ -1,41 +0,0 @@
|
||||
"""GPT Blocks used for the GPT Model."""
|
||||
from typing import Dict, Optional, Tuple
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
from .attention import ATTN_CLASS_REGISTRY
|
||||
from .norm import NORM_CLASS_REGISTRY
|
||||
|
||||
class MPTMLP(nn.Module):
|
||||
|
||||
def __init__(self, d_model: int, expansion_ratio: int, device: Optional[str]=None):
|
||||
super().__init__()
|
||||
self.up_proj = nn.Linear(d_model, expansion_ratio * d_model, device=device)
|
||||
self.act = nn.GELU(approximate='none')
|
||||
self.down_proj = nn.Linear(expansion_ratio * d_model, d_model, device=device)
|
||||
self.down_proj._is_residual = True
|
||||
|
||||
def forward(self, x):
|
||||
return self.down_proj(self.act(self.up_proj(x)))
|
||||
|
||||
class MPTBlock(nn.Module):
|
||||
|
||||
def __init__(self, d_model: int, n_heads: int, expansion_ratio: int, attn_config: Dict={'attn_type': 'multihead_attention', 'attn_pdrop': 0.0, 'attn_impl': 'triton', 'qk_ln': False, 'clip_qkv': None, 'softmax_scale': None, 'prefix_lm': False, 'attn_uses_sequence_id': False, 'alibi': False, 'alibi_bias_max': 8}, resid_pdrop: float=0.0, norm_type: str='low_precision_layernorm', device: Optional[str]=None, **kwargs):
|
||||
del kwargs
|
||||
super().__init__()
|
||||
norm_class = NORM_CLASS_REGISTRY[norm_type.lower()]
|
||||
attn_class = ATTN_CLASS_REGISTRY[attn_config['attn_type']]
|
||||
self.norm_1 = norm_class(d_model, device=device)
|
||||
self.attn = attn_class(attn_impl=attn_config['attn_impl'], clip_qkv=attn_config['clip_qkv'], qk_ln=attn_config['qk_ln'], softmax_scale=attn_config['softmax_scale'], attn_pdrop=attn_config['attn_pdrop'], d_model=d_model, n_heads=n_heads, device=device)
|
||||
self.norm_2 = norm_class(d_model, device=device)
|
||||
self.ffn = MPTMLP(d_model=d_model, expansion_ratio=expansion_ratio, device=device)
|
||||
self.resid_attn_dropout = nn.Dropout(resid_pdrop)
|
||||
self.resid_ffn_dropout = nn.Dropout(resid_pdrop)
|
||||
|
||||
def forward(self, x: torch.Tensor, past_key_value: Optional[Tuple[torch.Tensor]]=None, attn_bias: Optional[torch.Tensor]=None, attention_mask: Optional[torch.ByteTensor]=None, is_causal: bool=True) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor]]]:
|
||||
a = self.norm_1(x)
|
||||
(b, _, past_key_value) = self.attn(a, past_key_value=past_key_value, attn_bias=attn_bias, attention_mask=attention_mask, is_causal=is_causal)
|
||||
x = x + self.resid_attn_dropout(b)
|
||||
m = self.norm_2(x)
|
||||
n = self.ffn(m)
|
||||
x = x + self.resid_ffn_dropout(n)
|
||||
return (x, past_key_value)
|
||||
@@ -1,118 +0,0 @@
|
||||
"""A HuggingFace-style model configuration."""
|
||||
from typing import Dict, Optional, Union
|
||||
from transformers import PretrainedConfig
|
||||
attn_config_defaults: Dict = {'attn_type': 'multihead_attention', 'attn_pdrop': 0.0, 'attn_impl': 'triton', 'qk_ln': False, 'clip_qkv': None, 'softmax_scale': None, 'prefix_lm': False, 'attn_uses_sequence_id': False, 'alibi': False, 'alibi_bias_max': 8}
|
||||
init_config_defaults: Dict = {'name': 'kaiming_normal_', 'fan_mode': 'fan_in', 'init_nonlinearity': 'relu'}
|
||||
|
||||
class MPTConfig(PretrainedConfig):
|
||||
model_type = 'mpt'
|
||||
|
||||
def __init__(self, d_model: int=2048, n_heads: int=16, n_layers: int=24, expansion_ratio: int=4, max_seq_len: int=2048, vocab_size: int=50368, resid_pdrop: float=0.0, emb_pdrop: float=0.0, learned_pos_emb: bool=True, attn_config: Dict=attn_config_defaults, init_device: str='cpu', logit_scale: Optional[Union[float, str]]=None, no_bias: bool=False, verbose: int=0, embedding_fraction: float=1.0, norm_type: str='low_precision_layernorm', use_cache: bool=False, init_config: Dict=init_config_defaults, **kwargs):
|
||||
"""The MPT configuration class.
|
||||
|
||||
Args:
|
||||
d_model (int): The size of the embedding dimension of the model.
|
||||
n_heads (int): The number of attention heads.
|
||||
n_layers (int): The number of layers in the model.
|
||||
expansion_ratio (int): The ratio of the up/down scale in the MLP.
|
||||
max_seq_len (int): The maximum sequence length of the model.
|
||||
vocab_size (int): The size of the vocabulary.
|
||||
resid_pdrop (float): The dropout probability applied to the attention output before combining with residual.
|
||||
emb_pdrop (float): The dropout probability for the embedding layer.
|
||||
learned_pos_emb (bool): Whether to use learned positional embeddings
|
||||
attn_config (Dict): A dictionary used to configure the model's attention module:
|
||||
attn_type (str): type of attention to use. Options: multihead_attention, multiquery_attention
|
||||
attn_pdrop (float): The dropout probability for the attention layers.
|
||||
attn_impl (str): The attention implementation to use. One of 'torch', 'flash', or 'triton'.
|
||||
qk_ln (bool): Whether to apply layer normalization to the queries and keys in the attention layer.
|
||||
clip_qkv (Optional[float]): If not None, clip the queries, keys, and values in the attention layer to
|
||||
this value.
|
||||
softmax_scale (Optional[float]): If not None, scale the softmax in the attention layer by this value. If None,
|
||||
use the default scale of ``1/sqrt(d_keys)``.
|
||||
prefix_lm (Optional[bool]): Whether the model should operate as a Prefix LM. This requires passing an
|
||||
extra `prefix_mask` argument which indicates which tokens belong to the prefix. Tokens in the prefix
|
||||
can attend to one another bi-directionally. Tokens outside the prefix use causal attention.
|
||||
attn_uses_sequence_id (Optional[bool]): Whether to restrict attention to tokens that have the same sequence_id.
|
||||
When the model is in `train` mode, this requires passing an extra `sequence_id` argument which indicates
|
||||
which sub-sequence each token belongs to.
|
||||
Defaults to ``False`` meaning any provided `sequence_id` will be ignored.
|
||||
alibi (bool): Whether to use the alibi bias instead of position embeddings.
|
||||
alibi_bias_max (int): The maximum value of the alibi bias.
|
||||
init_device (str): The device to use for parameter initialization.
|
||||
logit_scale (Optional[Union[float, str]]): If not None, scale the logits by this value.
|
||||
no_bias (bool): Whether to use bias in all layers.
|
||||
verbose (int): The verbosity level. 0 is silent.
|
||||
embedding_fraction (float): The fraction to scale the gradients of the embedding layer by.
|
||||
norm_type (str): choose type of norm to use
|
||||
multiquery_attention (bool): Whether to use multiquery attention implementation.
|
||||
use_cache (bool): Whether or not the model should return the last key/values attentions
|
||||
init_config (Dict): A dictionary used to configure the model initialization:
|
||||
init_config.name: The parameter initialization scheme to use. Options: 'default_', 'baseline_',
|
||||
'kaiming_uniform_', 'kaiming_normal_', 'neox_init_', 'small_init_', 'xavier_uniform_', or
|
||||
'xavier_normal_'. These mimic the parameter initialization methods in PyTorch.
|
||||
init_div_is_residual (Union[int, float, str, bool]): Value to divide initial weights by if ``module._is_residual`` is True.
|
||||
emb_init_std (Optional[float]): The standard deviation of the normal distribution used to initialize the embedding layer.
|
||||
emb_init_uniform_lim (Optional[Union[Tuple[float, float], float]]): The lower and upper limits of the uniform distribution
|
||||
used to initialize the embedding layer. Mutually exclusive with ``emb_init_std``.
|
||||
init_std (float): The standard deviation of the normal distribution used to initialize the model,
|
||||
if using the baseline_ parameter initialization scheme.
|
||||
init_gain (float): The gain to use for parameter initialization with kaiming or xavier initialization schemes.
|
||||
fan_mode (str): The fan mode to use for parameter initialization with kaiming initialization schemes.
|
||||
init_nonlinearity (str): The nonlinearity to use for parameter initialization with kaiming initialization schemes.
|
||||
---
|
||||
See llmfoundry.models.utils.param_init_fns.py for info on other param init config options
|
||||
"""
|
||||
self.d_model = d_model
|
||||
self.n_heads = n_heads
|
||||
self.n_layers = n_layers
|
||||
self.expansion_ratio = expansion_ratio
|
||||
self.max_seq_len = max_seq_len
|
||||
self.vocab_size = vocab_size
|
||||
self.resid_pdrop = resid_pdrop
|
||||
self.emb_pdrop = emb_pdrop
|
||||
self.learned_pos_emb = learned_pos_emb
|
||||
self.attn_config = attn_config
|
||||
self.init_device = init_device
|
||||
self.logit_scale = logit_scale
|
||||
self.no_bias = no_bias
|
||||
self.verbose = verbose
|
||||
self.embedding_fraction = embedding_fraction
|
||||
self.norm_type = norm_type
|
||||
self.use_cache = use_cache
|
||||
self.init_config = init_config
|
||||
if 'name' in kwargs:
|
||||
del kwargs['name']
|
||||
if 'loss_fn' in kwargs:
|
||||
del kwargs['loss_fn']
|
||||
super().__init__(**kwargs)
|
||||
self._validate_config()
|
||||
|
||||
def _set_config_defaults(self, config, config_defaults):
|
||||
for (k, v) in config_defaults.items():
|
||||
if k not in config:
|
||||
config[k] = v
|
||||
return config
|
||||
|
||||
def _validate_config(self):
|
||||
self.attn_config = self._set_config_defaults(self.attn_config, attn_config_defaults)
|
||||
self.init_config = self._set_config_defaults(self.init_config, init_config_defaults)
|
||||
if self.d_model % self.n_heads != 0:
|
||||
raise ValueError('d_model must be divisible by n_heads')
|
||||
if any((prob < 0 or prob > 1 for prob in [self.attn_config['attn_pdrop'], self.resid_pdrop, self.emb_pdrop])):
|
||||
raise ValueError("self.attn_config['attn_pdrop'], resid_pdrop, emb_pdrop are probabilities and must be between 0 and 1")
|
||||
if self.attn_config['attn_impl'] not in ['torch', 'flash', 'triton']:
|
||||
raise ValueError(f"Unknown attn_impl={self.attn_config['attn_impl']}")
|
||||
if self.attn_config['prefix_lm'] and self.attn_config['attn_impl'] not in ['torch', 'triton']:
|
||||
raise NotImplementedError('prefix_lm only implemented with torch and triton attention.')
|
||||
if self.attn_config['alibi'] and self.attn_config['attn_impl'] not in ['torch', 'triton']:
|
||||
raise NotImplementedError('alibi only implemented with torch and triton attention.')
|
||||
if self.attn_config['attn_uses_sequence_id'] and self.attn_config['attn_impl'] not in ['torch', 'triton']:
|
||||
raise NotImplementedError('attn_uses_sequence_id only implemented with torch and triton attention.')
|
||||
if self.embedding_fraction > 1 or self.embedding_fraction <= 0:
|
||||
raise ValueError('model.embedding_fraction must be between 0 (exclusive) and 1 (inclusive)!')
|
||||
if isinstance(self.logit_scale, str) and self.logit_scale != 'inv_sqrt_d_model':
|
||||
raise ValueError(f"self.logit_scale={self.logit_scale!r} is not recognized as an option; use numeric value or 'inv_sqrt_d_model'.")
|
||||
if self.init_config.get('name', None) is None:
|
||||
raise ValueError(f"self.init_config={self.init_config!r} 'name' needs to be set.")
|
||||
if not self.learned_pos_emb and (not self.attn_config['alibi']):
|
||||
raise ValueError(f'Positional information must be provided to the model using either learned_pos_emb or alibi.')
|
||||
@@ -1,415 +0,0 @@
|
||||
"""Converts Huggingface Causal LM to Prefix LM.
|
||||
|
||||
Conversion does lightweight surgery on a HuggingFace
|
||||
Causal LM to convert it to a Prefix LM.
|
||||
|
||||
Prefix LMs accepts a `bidirectional_mask` input in `forward`
|
||||
and treat the input prompt as the prefix in `generate`.
|
||||
"""
|
||||
import math
|
||||
import warnings
|
||||
from types import MethodType
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
import torch
|
||||
from transformers.models.bloom.modeling_bloom import BaseModelOutputWithPastAndCrossAttentions, BloomForCausalLM, BloomModel, CausalLMOutputWithCrossAttentions, CrossEntropyLoss
|
||||
from transformers.models.bloom.modeling_bloom import _expand_mask as _expand_mask_bloom
|
||||
from transformers.models.bloom.modeling_bloom import _make_causal_mask as _make_causal_mask_bloom
|
||||
from transformers.models.bloom.modeling_bloom import logging
|
||||
from transformers.models.gpt2.modeling_gpt2 import GPT2LMHeadModel
|
||||
from transformers.models.gpt_neo.modeling_gpt_neo import GPTNeoForCausalLM
|
||||
from transformers.models.gpt_neox.modeling_gpt_neox import GPTNeoXForCausalLM
|
||||
from transformers.models.gptj.modeling_gptj import GPTJForCausalLM
|
||||
from transformers.models.opt.modeling_opt import OPTForCausalLM
|
||||
from transformers.models.opt.modeling_opt import _expand_mask as _expand_mask_opt
|
||||
from transformers.models.opt.modeling_opt import _make_causal_mask as _make_causal_mask_opt
|
||||
logger = logging.get_logger(__name__)
|
||||
_SUPPORTED_GPT_MODELS = (GPT2LMHeadModel, GPTJForCausalLM, GPTNeoForCausalLM, GPTNeoXForCausalLM)
|
||||
CAUSAL_GPT_TYPES = Union[GPT2LMHeadModel, GPTJForCausalLM, GPTNeoForCausalLM, GPTNeoXForCausalLM]
|
||||
|
||||
def _convert_gpt_causal_lm_to_prefix_lm(model: CAUSAL_GPT_TYPES) -> CAUSAL_GPT_TYPES:
|
||||
"""Converts a GPT-style Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `GPT2LMHeadModel`
|
||||
- `GPTNeoForCausalLM`
|
||||
- `GPTNeoXForCausalLM`
|
||||
- `GPTJForCausalLM`
|
||||
|
||||
See `convert_hf_causal_lm_to_prefix_lm` for more details.
|
||||
"""
|
||||
if hasattr(model, '_prefix_lm_converted'):
|
||||
return model
|
||||
assert isinstance(model, _SUPPORTED_GPT_MODELS)
|
||||
assert model.config.add_cross_attention == False, 'Only supports GPT-style decoder-only models'
|
||||
|
||||
def _get_attn_modules(model: CAUSAL_GPT_TYPES) -> List[torch.nn.Module]:
|
||||
"""Helper that gets a list of the model's attention modules.
|
||||
|
||||
Each module has a `bias` buffer used for causal masking. The Prefix LM
|
||||
conversion adds logic to dynamically manipulate these biases to support
|
||||
Prefix LM attention masking.
|
||||
"""
|
||||
attn_modules = []
|
||||
if isinstance(model, GPTNeoXForCausalLM):
|
||||
blocks = model.gpt_neox.layers
|
||||
else:
|
||||
blocks = model.transformer.h
|
||||
for block in blocks:
|
||||
if isinstance(model, GPTNeoForCausalLM):
|
||||
if block.attn.attention_type != 'global':
|
||||
continue
|
||||
attn_module = block.attn.attention
|
||||
elif isinstance(model, GPTNeoXForCausalLM):
|
||||
attn_module = block.attention
|
||||
else:
|
||||
attn_module = block.attn
|
||||
attn_modules.append(attn_module)
|
||||
return attn_modules
|
||||
setattr(model, '_original_forward', getattr(model, 'forward'))
|
||||
setattr(model, '_original_generate', getattr(model, 'generate'))
|
||||
|
||||
def forward(self: CAUSAL_GPT_TYPES, input_ids: Optional[torch.LongTensor]=None, past_key_values: Optional[Tuple[Tuple[torch.Tensor]]]=None, attention_mask: Optional[torch.FloatTensor]=None, bidirectional_mask: Optional[torch.Tensor]=None, token_type_ids: Optional[torch.LongTensor]=None, position_ids: Optional[torch.LongTensor]=None, head_mask: Optional[torch.FloatTensor]=None, inputs_embeds: Optional[torch.FloatTensor]=None, labels: Optional[torch.LongTensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None):
|
||||
"""Wraps original forward to enable PrefixLM attention."""
|
||||
|
||||
def call_og_forward():
|
||||
if isinstance(self, GPTNeoXForCausalLM):
|
||||
return self._original_forward(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, head_mask=head_mask, inputs_embeds=inputs_embeds, labels=labels, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
else:
|
||||
return self._original_forward(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, labels=labels, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
if bidirectional_mask is None:
|
||||
return call_og_forward()
|
||||
assert isinstance(bidirectional_mask, torch.Tensor)
|
||||
attn_modules = _get_attn_modules(model)
|
||||
(b, s) = bidirectional_mask.shape
|
||||
max_length = attn_modules[0].bias.shape[-1]
|
||||
if s > max_length:
|
||||
raise ValueError(f'bidirectional_mask sequence length (={s}) exceeds the ' + f'max length allowed by the model ({max_length}).')
|
||||
assert s <= max_length
|
||||
if s < max_length:
|
||||
pad = torch.zeros((int(b), int(max_length - s)), dtype=bidirectional_mask.dtype, device=bidirectional_mask.device)
|
||||
bidirectional_mask = torch.cat([bidirectional_mask, pad], dim=1)
|
||||
bidirectional = bidirectional_mask.unsqueeze(1).unsqueeze(1)
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data = torch.logical_or(attn_module.bias.data, bidirectional)
|
||||
output = call_og_forward()
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data = torch.tril(attn_module.bias.data[0, 0])[None, None]
|
||||
return output
|
||||
|
||||
def generate(self: CAUSAL_GPT_TYPES, *args: tuple, **kwargs: Dict[str, Any]):
|
||||
"""Wraps original generate to enable PrefixLM attention."""
|
||||
attn_modules = _get_attn_modules(model)
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data[:] = 1
|
||||
output = self._original_generate(*args, **kwargs)
|
||||
for attn_module in attn_modules:
|
||||
attn_module.bias.data = torch.tril(attn_module.bias.data[0, 0])[None, None]
|
||||
return output
|
||||
setattr(model, 'forward', MethodType(forward, model))
|
||||
setattr(model, 'generate', MethodType(generate, model))
|
||||
setattr(model, '_prefix_lm_converted', True)
|
||||
return model
|
||||
|
||||
def _convert_bloom_causal_lm_to_prefix_lm(model: BloomForCausalLM) -> BloomForCausalLM:
|
||||
"""Converts a BLOOM Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `BloomForCausalLM`
|
||||
|
||||
See `convert_hf_causal_lm_to_prefix_lm` for more details.
|
||||
"""
|
||||
if hasattr(model, '_prefix_lm_converted'):
|
||||
return model
|
||||
assert isinstance(model, BloomForCausalLM)
|
||||
assert model.config.add_cross_attention == False, 'Only supports BLOOM decoder-only models'
|
||||
|
||||
def _prepare_attn_mask(self: BloomModel, attention_mask: torch.Tensor, bidirectional_mask: Optional[torch.Tensor], input_shape: Tuple[int, int], past_key_values_length: int) -> torch.BoolTensor:
|
||||
combined_attention_mask = None
|
||||
device = attention_mask.device
|
||||
(_, src_length) = input_shape
|
||||
if src_length > 1:
|
||||
combined_attention_mask = _make_causal_mask_bloom(input_shape, device=device, past_key_values_length=past_key_values_length)
|
||||
if bidirectional_mask is not None:
|
||||
assert attention_mask.shape == bidirectional_mask.shape
|
||||
expanded_bidirectional_mask = _expand_mask_bloom(bidirectional_mask, tgt_length=src_length)
|
||||
combined_attention_mask = torch.logical_and(combined_attention_mask, expanded_bidirectional_mask)
|
||||
expanded_attn_mask = _expand_mask_bloom(attention_mask, tgt_length=src_length)
|
||||
combined_attention_mask = expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask | combined_attention_mask
|
||||
return combined_attention_mask
|
||||
|
||||
def _build_alibi_tensor(self: BloomModel, batch_size: int, query_length: int, key_length: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
|
||||
num_heads = self.config.n_head
|
||||
closest_power_of_2 = 2 ** math.floor(math.log2(num_heads))
|
||||
base = torch.tensor(2 ** (-2 ** (-(math.log2(closest_power_of_2) - 3))), device=device, dtype=torch.float32)
|
||||
powers = torch.arange(1, 1 + closest_power_of_2, device=device, dtype=torch.int32)
|
||||
slopes = torch.pow(base, powers)
|
||||
if closest_power_of_2 != num_heads:
|
||||
extra_base = torch.tensor(2 ** (-2 ** (-(math.log2(2 * closest_power_of_2) - 3))), device=device, dtype=torch.float32)
|
||||
num_remaining_heads = min(closest_power_of_2, num_heads - closest_power_of_2)
|
||||
extra_powers = torch.arange(1, 1 + 2 * num_remaining_heads, 2, device=device, dtype=torch.int32)
|
||||
slopes = torch.cat([slopes, torch.pow(extra_base, extra_powers)], dim=0)
|
||||
qa = torch.arange(query_length, device=device, dtype=torch.int32).view(-1, 1)
|
||||
ka = torch.arange(key_length, device=device, dtype=torch.int32).view(1, -1)
|
||||
diffs = qa - ka + key_length - query_length
|
||||
diffs = -diffs.abs()
|
||||
alibi = slopes.view(1, num_heads, 1, 1) * diffs.view(1, 1, query_length, key_length)
|
||||
alibi = alibi.expand(batch_size, -1, -1, -1).reshape(-1, query_length, key_length)
|
||||
return alibi.to(dtype)
|
||||
KeyValueT = Tuple[torch.Tensor, torch.Tensor]
|
||||
|
||||
def forward(self: BloomModel, input_ids: Optional[torch.LongTensor]=None, past_key_values: Optional[Tuple[KeyValueT, ...]]=None, attention_mask: Optional[torch.Tensor]=None, bidirectional_mask: Optional[torch.Tensor]=None, head_mask: Optional[torch.LongTensor]=None, inputs_embeds: Optional[torch.LongTensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, **deprecated_arguments) -> Union[Tuple[torch.Tensor, ...], BaseModelOutputWithPastAndCrossAttentions]:
|
||||
if deprecated_arguments.pop('position_ids', False) is not False:
|
||||
warnings.warn('`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. ' + 'You can safely ignore passing `position_ids`.', FutureWarning)
|
||||
if len(deprecated_arguments) > 0:
|
||||
raise ValueError(f'Got unexpected arguments: {deprecated_arguments}')
|
||||
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
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
||||
if input_ids is not None and inputs_embeds is not None:
|
||||
raise ValueError('You cannot specify both input_ids and inputs_embeds at the same time')
|
||||
elif input_ids is not None:
|
||||
(batch_size, seq_length) = input_ids.shape
|
||||
elif inputs_embeds is not None:
|
||||
(batch_size, seq_length, _) = inputs_embeds.shape
|
||||
else:
|
||||
raise ValueError('You have to specify either input_ids or inputs_embeds')
|
||||
if past_key_values is None:
|
||||
past_key_values = tuple([None] * len(self.h))
|
||||
head_mask = self.get_head_mask(head_mask, self.config.n_layer)
|
||||
if inputs_embeds is None:
|
||||
inputs_embeds = self.word_embeddings(input_ids)
|
||||
hidden_states = self.word_embeddings_layernorm(inputs_embeds)
|
||||
presents = () if use_cache else None
|
||||
all_self_attentions = () if output_attentions else None
|
||||
all_hidden_states = () if output_hidden_states else None
|
||||
seq_length_with_past = seq_length
|
||||
past_key_values_length = 0
|
||||
if past_key_values[0] is not None:
|
||||
tmp = past_key_values[0][0]
|
||||
past_key_values_length = tmp.shape[2]
|
||||
seq_length_with_past = seq_length_with_past + past_key_values_length
|
||||
if attention_mask is None:
|
||||
attention_mask = torch.ones((batch_size, seq_length_with_past), device=hidden_states.device)
|
||||
else:
|
||||
attention_mask = attention_mask.to(hidden_states.device)
|
||||
alibi = self._build_alibi_tensor(batch_size=batch_size, query_length=seq_length, key_length=seq_length_with_past, dtype=hidden_states.dtype, device=hidden_states.device)
|
||||
causal_mask = self._prepare_attn_mask(attention_mask, bidirectional_mask, input_shape=(batch_size, seq_length), past_key_values_length=past_key_values_length)
|
||||
for (i, (block, layer_past)) in enumerate(zip(self.h, past_key_values)):
|
||||
if output_hidden_states:
|
||||
hst = (hidden_states,)
|
||||
all_hidden_states = all_hidden_states + hst
|
||||
if self.gradient_checkpointing and self.training:
|
||||
if use_cache:
|
||||
logger.warning('`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, use_cache=use_cache, output_attentions=output_attentions)
|
||||
return custom_forward
|
||||
outputs = torch.utils.checkpoint.checkpoint(create_custom_forward(block), hidden_states, alibi, causal_mask, head_mask[i])
|
||||
else:
|
||||
outputs = block(hidden_states, layer_past=layer_past, attention_mask=causal_mask, head_mask=head_mask[i], use_cache=use_cache, output_attentions=output_attentions, alibi=alibi)
|
||||
hidden_states = outputs[0]
|
||||
if use_cache is True:
|
||||
presents = presents + (outputs[1],)
|
||||
if output_attentions:
|
||||
oa = (outputs[2 if use_cache else 1],)
|
||||
all_self_attentions = all_self_attentions + oa
|
||||
hidden_states = self.ln_f(hidden_states)
|
||||
if output_hidden_states:
|
||||
hst = (hidden_states,)
|
||||
all_hidden_states = all_hidden_states + hst
|
||||
if not return_dict:
|
||||
return tuple((v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] if v is not None))
|
||||
return BaseModelOutputWithPastAndCrossAttentions(last_hidden_state=hidden_states, past_key_values=presents, hidden_states=all_hidden_states, attentions=all_self_attentions)
|
||||
setattr(model.transformer, '_prepare_attn_mask', MethodType(_prepare_attn_mask, model.transformer))
|
||||
setattr(model.transformer, '_build_alibi_tensor', MethodType(_build_alibi_tensor, model.transformer))
|
||||
setattr(model.transformer, 'forward', MethodType(forward, model.transformer))
|
||||
KeyValueT = Tuple[torch.Tensor, torch.Tensor]
|
||||
|
||||
def forward(self: BloomForCausalLM, input_ids: Optional[torch.LongTensor]=None, past_key_values: Optional[Tuple[KeyValueT, ...]]=None, attention_mask: Optional[torch.Tensor]=None, bidirectional_mask: Optional[torch.Tensor]=None, head_mask: Optional[torch.Tensor]=None, inputs_embeds: Optional[torch.Tensor]=None, labels: Optional[torch.Tensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, **deprecated_arguments) -> Union[Tuple[torch.Tensor], CausalLMOutputWithCrossAttentions]:
|
||||
"""Replacement forward method for BloomCausalLM."""
|
||||
if deprecated_arguments.pop('position_ids', False) is not False:
|
||||
warnings.warn('`position_ids` have no functionality in BLOOM and will be removed ' + 'in v5.0.0. You can safely ignore passing `position_ids`.', FutureWarning)
|
||||
if len(deprecated_arguments) > 0:
|
||||
raise ValueError(f'Got unexpected arguments: {deprecated_arguments}')
|
||||
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
||||
transformer_outputs = self.transformer(input_ids, past_key_values=past_key_values, attention_mask=attention_mask, bidirectional_mask=bidirectional_mask, head_mask=head_mask, inputs_embeds=inputs_embeds, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
hidden_states = transformer_outputs[0]
|
||||
lm_logits = self.lm_head(hidden_states)
|
||||
loss = None
|
||||
if labels is not None:
|
||||
shift_logits = lm_logits[..., :-1, :].contiguous()
|
||||
shift_labels = labels[..., 1:].contiguous()
|
||||
(batch_size, seq_length, vocab_size) = shift_logits.shape
|
||||
loss_fct = CrossEntropyLoss()
|
||||
loss = loss_fct(shift_logits.view(batch_size * seq_length, vocab_size), shift_labels.view(batch_size * seq_length))
|
||||
if not return_dict:
|
||||
output = (lm_logits,) + transformer_outputs[1:]
|
||||
return (loss,) + output if loss is not None else output
|
||||
return CausalLMOutputWithCrossAttentions(loss=loss, logits=lm_logits, past_key_values=transformer_outputs.past_key_values, hidden_states=transformer_outputs.hidden_states, attentions=transformer_outputs.attentions)
|
||||
|
||||
def prepare_inputs_for_generation(self: BloomForCausalLM, input_ids: torch.LongTensor, past: Optional[torch.Tensor]=None, attention_mask: Optional[torch.Tensor]=None, **kwargs) -> dict:
|
||||
if past:
|
||||
input_ids = input_ids[:, -1].unsqueeze(-1)
|
||||
bidirectional_mask = None
|
||||
if past[0][0].shape[0] == input_ids.shape[0]:
|
||||
past = self._convert_to_bloom_cache(past)
|
||||
else:
|
||||
bidirectional_mask = torch.ones_like(input_ids)
|
||||
return {'input_ids': input_ids, 'past_key_values': past, 'use_cache': True, 'attention_mask': attention_mask, 'bidirectional_mask': bidirectional_mask}
|
||||
setattr(model, 'forward', MethodType(forward, model))
|
||||
setattr(model, 'prepare_inputs_for_generation', MethodType(prepare_inputs_for_generation, model))
|
||||
setattr(model, '_prefix_lm_converted', True)
|
||||
return model
|
||||
|
||||
def _convert_opt_causal_lm_to_prefix_lm(model: OPTForCausalLM) -> OPTForCausalLM:
|
||||
"""Converts an OPT Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `OPTForCausalLM`
|
||||
|
||||
See `convert_hf_causal_lm_to_prefix_lm` for more details.
|
||||
"""
|
||||
if hasattr(model, '_prefix_lm_converted'):
|
||||
return model
|
||||
assert isinstance(model, OPTForCausalLM)
|
||||
assert model.config.add_cross_attention == False, 'Only supports OPT decoder-only models'
|
||||
setattr(model, '_original_forward', getattr(model, 'forward'))
|
||||
setattr(model, '_original_generate', getattr(model, 'generate'))
|
||||
model.model.decoder.bidirectional_mask = None
|
||||
|
||||
def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
|
||||
combined_attention_mask = None
|
||||
if input_shape[-1] > 1:
|
||||
if self.bidirectional_mask == 'g':
|
||||
(bsz, src_length) = input_shape
|
||||
combined_attention_mask = torch.zeros((bsz, 1, src_length, src_length + past_key_values_length), dtype=inputs_embeds.dtype, device=inputs_embeds.device)
|
||||
else:
|
||||
combined_attention_mask = _make_causal_mask_opt(input_shape, inputs_embeds.dtype, past_key_values_length=past_key_values_length).to(inputs_embeds.device)
|
||||
if self.bidirectional_mask is not None:
|
||||
assert attention_mask.shape == self.bidirectional_mask.shape
|
||||
expanded_bidirectional_mask = _expand_mask_opt(self.bidirectional_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(inputs_embeds.device)
|
||||
combined_attention_mask = torch.maximum(expanded_bidirectional_mask, combined_attention_mask)
|
||||
if attention_mask is not None:
|
||||
expanded_attn_mask = _expand_mask_opt(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(inputs_embeds.device)
|
||||
combined_attention_mask = expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
|
||||
return combined_attention_mask
|
||||
setattr(model.model.decoder, '_prepare_decoder_attention_mask', MethodType(_prepare_decoder_attention_mask, model.model.decoder))
|
||||
|
||||
def forward(self: OPTForCausalLM, input_ids: Optional[torch.LongTensor]=None, attention_mask: Optional[torch.Tensor]=None, bidirectional_mask: Optional[torch.ByteTensor]=None, head_mask: Optional[torch.Tensor]=None, past_key_values: Optional[List[torch.FloatTensor]]=None, inputs_embeds: Optional[torch.FloatTensor]=None, labels: Optional[torch.LongTensor]=None, use_cache: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None):
|
||||
|
||||
def call_og_forward():
|
||||
return self._original_forward(input_ids=input_ids, attention_mask=attention_mask, head_mask=head_mask, past_key_values=past_key_values, inputs_embeds=inputs_embeds, labels=labels, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
|
||||
if bidirectional_mask is None:
|
||||
return call_og_forward()
|
||||
self.model.decoder.bidirectional_mask = bidirectional_mask
|
||||
try:
|
||||
outputs = call_og_forward()
|
||||
except:
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
raise
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
return outputs
|
||||
|
||||
def generate(self: OPTForCausalLM, *args: tuple, **kwargs: Dict[str, Any]):
|
||||
"""Wraps original generate to enable PrefixLM-style attention."""
|
||||
self.model.decoder.bidirectional_mask = 'g'
|
||||
try:
|
||||
output = self._original_generate(*args, **kwargs)
|
||||
except:
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
raise
|
||||
self.model.decoder.bidirectional_mask = None
|
||||
return output
|
||||
setattr(model, 'forward', MethodType(forward, model))
|
||||
setattr(model, 'generate', MethodType(generate, model))
|
||||
setattr(model, '_prefix_lm_converted', True)
|
||||
return model
|
||||
_SUPPORTED_HF_MODELS = _SUPPORTED_GPT_MODELS + (BloomForCausalLM, OPTForCausalLM)
|
||||
CAUSAL_LM_TYPES = Union[GPT2LMHeadModel, GPTJForCausalLM, GPTNeoForCausalLM, GPTNeoXForCausalLM, BloomForCausalLM, OPTForCausalLM]
|
||||
|
||||
def convert_hf_causal_lm_to_prefix_lm(model: CAUSAL_LM_TYPES) -> CAUSAL_LM_TYPES:
|
||||
"""Converts a HuggingFace Causal LM to a Prefix LM.
|
||||
|
||||
Supported HuggingFace model classes:
|
||||
- `GPT2LMHeadModel`
|
||||
- `GPTNeoForCausalLM`
|
||||
- `GPTNeoXForCausalLM`
|
||||
- `GPTJForCausalLM`
|
||||
- `BloomForCausalLM`
|
||||
- `OPTForCausalLM`
|
||||
|
||||
Conversion to a Prefix LM is done by modifying the `forward` method, and possibly also the
|
||||
`generate` method and/or select underlying methods depending on the model class.
|
||||
|
||||
These changes preserve the model API, but add a new input to `forward`: "bidirectional_mask".
|
||||
|
||||
Notes on training:
|
||||
To actually train the converted model as a Prefix LM, training batches will need to indicate
|
||||
the prefix/target structure by including `bidirectional_mask` as part of the batch inputs.
|
||||
|
||||
**This is not a standard input and requires custom layers either within or after your dataloader.**
|
||||
|
||||
In addition to adding `bidirectional_mask` to the batch, this custom code should modify `labels`
|
||||
such that `batch['labels'][batch['bidirectional_mask'] == 1] == -100`.
|
||||
That is, the prefix portion of the sequence should not generate any loss. Loss should only be
|
||||
generated by the target portion of the sequence.
|
||||
|
||||
Notes on `GPTNeoForCausalLM`:
|
||||
To simplify the implementation, "global" and "local" attention layers are handled differently.
|
||||
For "global" layers, we handle conversion as described above. For "local" layers, which use a
|
||||
causal attention mask within a restricted local window, we do not alter the masking.
|
||||
|
||||
Notes on `forward` method conversion:
|
||||
After conversion, the `forward` method will handle a new input, `bidirectional_mask`,
|
||||
which should be a [batch_size, seq_length] byte tensor, where 1 indicates token positions
|
||||
belonging to the prefix (prefix tokens can attend to one another bidirectionally), and
|
||||
0 indicates token positions belonging to the target.
|
||||
|
||||
The new `forward` method will incorporate `bidirectional_mask` (if supplied) into the existing
|
||||
causal mask, call the original `forward` method, and (if the causal mask is a buffer) reset
|
||||
the causal masks before returning the result.
|
||||
|
||||
Notes on `generate` method conversion:
|
||||
After conversion, the `generate` method will have the same signature but will internally
|
||||
convert all causal masks to be purely bidirectional, call the original `generate` method, and
|
||||
(where appropriate) reset the causal masks before returning the result.
|
||||
|
||||
This works thanks to the logic of the HuggingFace `generate` API, which first encodes the token
|
||||
"prompt" passed to `generate` (which is treated as the prefix) and then sequentially generates
|
||||
each new token. Encodings are cached as generation happens, so all prefix tokens can attend to one
|
||||
another (as expected in a Prefix LM) and generated tokens can only attend to prefix tokens and
|
||||
previously-generated tokens (also as expected in a Prefix LM).
|
||||
|
||||
To preserve the API, the original methods are renamed to `_original_forward` and
|
||||
`_original_generate`, and replaced with new `forward` and `generate` methods that wrap
|
||||
them, respectively. Although implementation details vary by model class.
|
||||
"""
|
||||
if isinstance(model, _SUPPORTED_GPT_MODELS):
|
||||
return _convert_gpt_causal_lm_to_prefix_lm(model)
|
||||
elif isinstance(model, BloomForCausalLM):
|
||||
return _convert_bloom_causal_lm_to_prefix_lm(model)
|
||||
elif isinstance(model, OPTForCausalLM):
|
||||
return _convert_opt_causal_lm_to_prefix_lm(model)
|
||||
else:
|
||||
raise TypeError(f'Cannot convert model to Prefix LM. ' + f'Model does not belong to set of supported HF models:' + f'\n{_SUPPORTED_HF_MODELS}')
|
||||
|
||||
def add_bidirectional_mask_if_missing(batch: Dict[str, Any]):
|
||||
"""Attempts to add bidirectional_mask to batch if missing.
|
||||
|
||||
Raises:
|
||||
KeyError if bidirectional_mask is missing and can't be inferred
|
||||
"""
|
||||
if 'bidirectional_mask' not in batch:
|
||||
if batch.get('mode', None) == 'icl_task':
|
||||
batch['bidirectional_mask'] = batch['attention_mask'].clone()
|
||||
for (i, continuation_indices) in enumerate(batch['continuation_indices']):
|
||||
batch['bidirectional_mask'][i, continuation_indices] = 0
|
||||
elif 'labels' in batch and 'attention_mask' in batch:
|
||||
batch['bidirectional_mask'] = torch.logical_and(torch.eq(batch['attention_mask'], 1), torch.eq(batch['labels'], -100)).type_as(batch['attention_mask'])
|
||||
else:
|
||||
raise KeyError('No bidirectional_mask in batch and not sure how to construct one.')
|
||||
@@ -1,94 +0,0 @@
|
||||
from contextlib import contextmanager
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
|
||||
@contextmanager
|
||||
def init_empty_weights(include_buffers: bool=False):
|
||||
"""Meta initialization context manager.
|
||||
|
||||
A context manager under which models are initialized with all parameters
|
||||
on the meta device, therefore creating an empty model. Useful when just
|
||||
initializing the model would blow the available RAM.
|
||||
|
||||
Args:
|
||||
include_buffers (`bool`, *optional*, defaults to `False`): Whether or
|
||||
not to also put all buffers on the meta device while initializing.
|
||||
|
||||
Example:
|
||||
```python
|
||||
import torch.nn as nn
|
||||
|
||||
# Initialize a model with 100 billions parameters in no time and without using any RAM.
|
||||
with init_empty_weights():
|
||||
tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])
|
||||
```
|
||||
|
||||
<Tip warning={true}>
|
||||
|
||||
Any model created under this context manager has no weights. As such you can't do something like
|
||||
`model.to(some_device)` with it. To load weights inside your empty model, see [`load_checkpoint_and_dispatch`].
|
||||
|
||||
</Tip>
|
||||
"""
|
||||
with init_on_device(torch.device('meta'), include_buffers=include_buffers) as f:
|
||||
yield f
|
||||
|
||||
@contextmanager
|
||||
def init_on_device(device: torch.device, include_buffers: bool=False):
|
||||
"""Device initialization context manager.
|
||||
|
||||
A context manager under which models are initialized with all parameters
|
||||
on the specified device.
|
||||
|
||||
Args:
|
||||
device (`torch.device`): Device to initialize all parameters on.
|
||||
include_buffers (`bool`, *optional*, defaults to `False`): Whether or
|
||||
not to also put all buffers on the meta device while initializing.
|
||||
|
||||
Example:
|
||||
```python
|
||||
import torch.nn as nn
|
||||
|
||||
with init_on_device(device=torch.device("cuda")):
|
||||
tst = nn.Liner(100, 100) # on `cuda` device
|
||||
```
|
||||
"""
|
||||
old_register_parameter = nn.Module.register_parameter
|
||||
if include_buffers:
|
||||
old_register_buffer = nn.Module.register_buffer
|
||||
|
||||
def register_empty_parameter(module, name, param):
|
||||
old_register_parameter(module, name, param)
|
||||
if param is not None:
|
||||
param_cls = type(module._parameters[name])
|
||||
kwargs = module._parameters[name].__dict__
|
||||
module._parameters[name] = param_cls(module._parameters[name].to(device), **kwargs)
|
||||
|
||||
def register_empty_buffer(module, name, buffer):
|
||||
old_register_buffer(module, name, buffer)
|
||||
if buffer is not None:
|
||||
module._buffers[name] = module._buffers[name].to(device)
|
||||
if include_buffers:
|
||||
tensor_constructors_to_patch = {torch_function_name: getattr(torch, torch_function_name) for torch_function_name in ['empty', 'zeros', 'ones', 'full']}
|
||||
else:
|
||||
tensor_constructors_to_patch = {}
|
||||
|
||||
def patch_tensor_constructor(fn):
|
||||
|
||||
def wrapper(*args, **kwargs):
|
||||
kwargs['device'] = device
|
||||
return fn(*args, **kwargs)
|
||||
return wrapper
|
||||
try:
|
||||
nn.Module.register_parameter = register_empty_parameter
|
||||
if include_buffers:
|
||||
nn.Module.register_buffer = register_empty_buffer
|
||||
for torch_function_name in tensor_constructors_to_patch.keys():
|
||||
setattr(torch, torch_function_name, patch_tensor_constructor(getattr(torch, torch_function_name)))
|
||||
yield
|
||||
finally:
|
||||
nn.Module.register_parameter = old_register_parameter
|
||||
if include_buffers:
|
||||
nn.Module.register_buffer = old_register_buffer
|
||||
for (torch_function_name, old_torch_function) in tensor_constructors_to_patch.items():
|
||||
setattr(torch, torch_function_name, old_torch_function)
|
||||
@@ -1,311 +0,0 @@
|
||||
"""A simple, flexible implementation of a GPT model.
|
||||
|
||||
Inspired by https://github.com/karpathy/minGPT/blob/master/mingpt/model.py
|
||||
"""
|
||||
import math
|
||||
import warnings
|
||||
from typing import List, Optional, Tuple, Union
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.nn.functional as F
|
||||
from transformers import PreTrainedModel, PreTrainedTokenizer, PreTrainedTokenizerFast
|
||||
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
|
||||
from .attention import attn_bias_shape, build_attn_bias
|
||||
from .blocks import MPTBlock
|
||||
from .norm import NORM_CLASS_REGISTRY
|
||||
from .configuration_mpt import MPTConfig
|
||||
from .adapt_tokenizer import AutoTokenizerForMOD, adapt_tokenizer_for_denoising
|
||||
from .hf_prefixlm_converter import add_bidirectional_mask_if_missing, convert_hf_causal_lm_to_prefix_lm
|
||||
from .meta_init_context import init_empty_weights
|
||||
from .param_init_fns import MODEL_INIT_REGISTRY, generic_param_init_fn_
|
||||
Tokenizer = Union[PreTrainedTokenizer, PreTrainedTokenizerFast]
|
||||
|
||||
from transformers.utils import logging
|
||||
logger = logging.get_logger(__name__)
|
||||
|
||||
class MPTPreTrainedModel(PreTrainedModel):
|
||||
config_class = MPTConfig
|
||||
base_model_prefix = 'model'
|
||||
|
||||
class MPTModel(MPTPreTrainedModel):
|
||||
|
||||
def __init__(self, config: MPTConfig):
|
||||
config._validate_config()
|
||||
super().__init__(config)
|
||||
self.attn_impl = config.attn_config['attn_impl']
|
||||
self.prefix_lm = config.attn_config['prefix_lm']
|
||||
self.attn_uses_sequence_id = config.attn_config['attn_uses_sequence_id']
|
||||
self.alibi = config.attn_config['alibi']
|
||||
self.alibi_bias_max = config.attn_config['alibi_bias_max']
|
||||
if config.norm_type.lower() not in NORM_CLASS_REGISTRY.keys():
|
||||
norm_options = ' | '.join(NORM_CLASS_REGISTRY.keys())
|
||||
raise NotImplementedError(f'Requested norm type ({config.norm_type}) is not implemented within this repo (Options: {norm_options}).')
|
||||
norm_class = NORM_CLASS_REGISTRY[config.norm_type.lower()]
|
||||
self.embedding_fraction = config.embedding_fraction
|
||||
self.wte = nn.Embedding(config.vocab_size, config.d_model, device=config.init_device)
|
||||
if not self.alibi:
|
||||
self.wpe = nn.Embedding(config.max_seq_len, config.d_model, device=config.init_device)
|
||||
self.emb_drop = nn.Dropout(config.emb_pdrop)
|
||||
self.blocks = nn.ModuleList([MPTBlock(device=config.init_device, **config.to_dict()) for _ in range(config.n_layers)])
|
||||
self.norm_f = norm_class(config.d_model, device=config.init_device)
|
||||
if config.init_device != 'meta':
|
||||
self.apply(self.param_init_fn)
|
||||
self.is_causal = not self.prefix_lm
|
||||
self._attn_bias_initialized = False
|
||||
self.attn_bias = None
|
||||
self.attn_bias_shape = attn_bias_shape(self.attn_impl, config.n_heads, config.max_seq_len, self.alibi, prefix_lm=self.prefix_lm, causal=self.is_causal, use_sequence_id=self.attn_uses_sequence_id)
|
||||
if config.no_bias:
|
||||
for module in self.modules():
|
||||
if hasattr(module, 'bias') and isinstance(module.bias, nn.Parameter):
|
||||
if config.verbose:
|
||||
warnings.warn(f'Removing bias ({module.bias}) from {module}.')
|
||||
module.register_parameter('bias', None)
|
||||
if config.verbose and config.verbose > 2:
|
||||
print(self)
|
||||
if 'verbose' not in self.config.init_config:
|
||||
self.config.init_config['verbose'] = self.config.verbose
|
||||
if self.config.init_config['verbose'] > 1:
|
||||
init_fn_name = self.config.init_config['name']
|
||||
warnings.warn(f'Using {init_fn_name} initialization.')
|
||||
self.gradient_checkpointing = False
|
||||
|
||||
def get_input_embeddings(self):
|
||||
return self.wte
|
||||
|
||||
def set_input_embeddings(self, value):
|
||||
self.wte = value
|
||||
|
||||
@torch.no_grad()
|
||||
def _attn_bias(self, device, dtype, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None):
|
||||
if not self._attn_bias_initialized:
|
||||
if self.attn_bias_shape:
|
||||
self.attn_bias = torch.zeros(self.attn_bias_shape, device=device, dtype=dtype)
|
||||
self.attn_bias = build_attn_bias(self.attn_impl, self.attn_bias, self.config.n_heads, self.config.max_seq_len, causal=self.is_causal, alibi=self.alibi, alibi_bias_max=self.alibi_bias_max)
|
||||
self._attn_bias_initialized = True
|
||||
if self.attn_impl == 'flash':
|
||||
return (self.attn_bias, attention_mask)
|
||||
if self.attn_bias is not None:
|
||||
self.attn_bias = self.attn_bias.to(dtype=dtype, device=device)
|
||||
attn_bias = self.attn_bias
|
||||
if self.prefix_lm:
|
||||
assert isinstance(attn_bias, torch.Tensor)
|
||||
assert isinstance(prefix_mask, torch.Tensor)
|
||||
attn_bias = self._apply_prefix_mask(attn_bias, prefix_mask)
|
||||
if self.attn_uses_sequence_id and sequence_id is not None:
|
||||
assert isinstance(attn_bias, torch.Tensor)
|
||||
attn_bias = self._apply_sequence_id(attn_bias, sequence_id)
|
||||
if attention_mask is not None:
|
||||
s_k = attention_mask.shape[-1]
|
||||
if attn_bias is None:
|
||||
attn_bias = torch.zeros((1, 1, 1, s_k), device=device, dtype=dtype)
|
||||
else:
|
||||
attn_bias = attn_bias[:, :, :, -s_k:]
|
||||
if prefix_mask is not None and attention_mask.shape != prefix_mask.shape:
|
||||
raise ValueError(f'attention_mask shape={attention_mask.shape} ' + f'and prefix_mask shape={prefix_mask.shape} are not equal.')
|
||||
min_val = torch.finfo(attn_bias.dtype).min
|
||||
attn_bias = attn_bias.masked_fill(~attention_mask.view(-1, 1, 1, s_k), min_val)
|
||||
return (attn_bias, None)
|
||||
|
||||
def _apply_prefix_mask(self, attn_bias: torch.Tensor, prefix_mask: torch.Tensor):
|
||||
(s_k, s_q) = attn_bias.shape[-2:]
|
||||
if s_k != self.config.max_seq_len or s_q != self.config.max_seq_len:
|
||||
raise ValueError('attn_bias does not match the expected shape. ' + f'The last two dimensions should both be {self.config.max_length} ' + f'but are {s_k} and {s_q}.')
|
||||
seq_len = prefix_mask.shape[-1]
|
||||
if seq_len > self.config.max_seq_len:
|
||||
raise ValueError(f'prefix_mask sequence length cannot exceed max_seq_len={self.config.max_seq_len}')
|
||||
attn_bias = attn_bias[..., :seq_len, :seq_len]
|
||||
causal = torch.tril(torch.ones((seq_len, seq_len), dtype=torch.bool, device=prefix_mask.device)).view(1, 1, seq_len, seq_len)
|
||||
prefix = prefix_mask.view(-1, 1, 1, seq_len)
|
||||
cannot_attend = ~torch.logical_or(causal, prefix.bool())
|
||||
min_val = torch.finfo(attn_bias.dtype).min
|
||||
attn_bias = attn_bias.masked_fill(cannot_attend, min_val)
|
||||
return attn_bias
|
||||
|
||||
def _apply_sequence_id(self, attn_bias: torch.Tensor, sequence_id: torch.LongTensor):
|
||||
seq_len = sequence_id.shape[-1]
|
||||
if seq_len > self.config.max_seq_len:
|
||||
raise ValueError(f'sequence_id sequence length cannot exceed max_seq_len={self.config.max_seq_len}')
|
||||
attn_bias = attn_bias[..., :seq_len, :seq_len]
|
||||
cannot_attend = torch.logical_not(torch.eq(sequence_id.view(-1, seq_len, 1), sequence_id.view(-1, 1, seq_len))).unsqueeze(1)
|
||||
min_val = torch.finfo(attn_bias.dtype).min
|
||||
attn_bias = attn_bias.masked_fill(cannot_attend, min_val)
|
||||
return attn_bias
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None, tok_emb: Optional[torch.FloatTensor]=None):
|
||||
return_dict = return_dict if return_dict is not None else self.config.return_dict
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
|
||||
if self.gradient_checkpointing and self.training:
|
||||
if use_cache:
|
||||
logger.warning_once(
|
||||
"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
|
||||
)
|
||||
use_cache = False
|
||||
if attention_mask is not None:
|
||||
attention_mask = attention_mask.bool()
|
||||
if prefix_mask is not None:
|
||||
prefix_mask = prefix_mask.bool()
|
||||
if not return_dict:
|
||||
raise NotImplementedError('return_dict False is not implemented yet for MPT')
|
||||
if output_attentions:
|
||||
raise NotImplementedError('output_attentions is not implemented yet for MPT')
|
||||
if attention_mask is not None and attention_mask[:, 0].sum() != attention_mask.shape[0] and self.training:
|
||||
raise NotImplementedError('MPT does not support training with left padding.')
|
||||
if self.prefix_lm and prefix_mask is None:
|
||||
raise ValueError('prefix_mask is a required argument when MPT is configured with prefix_lm=True.')
|
||||
if self.training:
|
||||
if self.attn_uses_sequence_id and sequence_id is None:
|
||||
raise ValueError('sequence_id is a required argument when MPT is configured with attn_uses_sequence_id=True ' + 'and the model is in train mode.')
|
||||
elif self.attn_uses_sequence_id is False and sequence_id is not None:
|
||||
warnings.warn('MPT received non-None input for `sequence_id` but is configured with attn_uses_sequence_id=False. ' + 'This input will be ignored. If you want the model to use `sequence_id`, set attn_uses_sequence_id to True.')
|
||||
if input_ids is not None:
|
||||
S = input_ids.size(1)
|
||||
assert S <= self.config.max_seq_len, f'Cannot forward input with seq_len={S}, this model only supports seq_len<={self.config.max_seq_len}'
|
||||
tok_emb = self.wte(input_ids)
|
||||
else:
|
||||
assert tok_emb is not None
|
||||
S = tok_emb.size(1)
|
||||
if self.alibi:
|
||||
x = tok_emb
|
||||
else:
|
||||
past_position = 0
|
||||
if past_key_values is not None:
|
||||
if len(past_key_values) != self.config.n_layers:
|
||||
raise ValueError(f'past_key_values must provide a past_key_value for each attention ' + f'layer in the network (len(past_key_values)={len(past_key_values)!r}; self.config.n_layers={self.config.n_layers!r}).')
|
||||
past_position = past_key_values[0][0].size(1)
|
||||
if S + past_position > self.config.max_seq_len:
|
||||
raise ValueError(f'Cannot forward input with past sequence length {past_position} and current sequence length {S + 1}, this model only supports total sequence length <= {self.config.max_seq_len}.')
|
||||
pos = torch.arange(past_position, S + past_position, dtype=torch.long, device=input_ids.device).unsqueeze(0)
|
||||
if attention_mask is not None:
|
||||
pos = torch.clamp(pos - torch.cumsum((~attention_mask).to(torch.int32), dim=1)[:, past_position:], min=0)
|
||||
pos_emb = self.wpe(pos)
|
||||
x = tok_emb + pos_emb
|
||||
if self.embedding_fraction == 1:
|
||||
x = self.emb_drop(x)
|
||||
else:
|
||||
x_shrunk = x * self.embedding_fraction + x.detach() * (1 - self.embedding_fraction)
|
||||
assert isinstance(self.emb_drop, nn.Module)
|
||||
x = self.emb_drop(x_shrunk)
|
||||
(attn_bias, attention_mask) = self._attn_bias(device=x.device, dtype=x.dtype, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id)
|
||||
if use_cache and past_key_values is None:
|
||||
past_key_values = [() for _ in range(self.config.n_layers)]
|
||||
all_hidden_states = () if output_hidden_states else None
|
||||
for (b_idx, block) in enumerate(self.blocks):
|
||||
if output_hidden_states:
|
||||
assert all_hidden_states is not None
|
||||
all_hidden_states = all_hidden_states + (x,)
|
||||
past_key_value = past_key_values[b_idx] if past_key_values is not None else None
|
||||
if self.gradient_checkpointing and self.training:
|
||||
(x, past_key_value) = torch.utils.checkpoint.checkpoint(
|
||||
block,
|
||||
x, past_key_value, attn_bias, attention_mask, self.is_causal
|
||||
)
|
||||
else:
|
||||
(x, past_key_value) = block(x, past_key_value=past_key_value, attn_bias=attn_bias, attention_mask=attention_mask, is_causal=self.is_causal)
|
||||
if past_key_values is not None:
|
||||
past_key_values[b_idx] = past_key_value
|
||||
x = self.norm_f(x)
|
||||
return BaseModelOutputWithPast(last_hidden_state=x, past_key_values=past_key_values, hidden_states=all_hidden_states)
|
||||
|
||||
def param_init_fn(self, module):
|
||||
init_fn_name = self.config.init_config['name']
|
||||
MODEL_INIT_REGISTRY[init_fn_name](module=module, n_layers=self.config.n_layers, d_model=self.config.d_model, **self.config.init_config)
|
||||
|
||||
def fsdp_wrap_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
def activation_checkpointing_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
class MPTForCausalLM(MPTPreTrainedModel):
|
||||
|
||||
def __init__(self, config: MPTConfig):
|
||||
super().__init__(config)
|
||||
if not config.tie_word_embeddings:
|
||||
raise ValueError('MPTForCausalLM only supports tied word embeddings')
|
||||
self.transformer = MPTModel(config)
|
||||
self.logit_scale = None
|
||||
if config.logit_scale is not None:
|
||||
logit_scale = config.logit_scale
|
||||
if isinstance(logit_scale, str):
|
||||
if logit_scale == 'inv_sqrt_d_model':
|
||||
logit_scale = 1 / math.sqrt(config.d_model)
|
||||
else:
|
||||
raise ValueError(f"logit_scale={logit_scale!r} is not recognized as an option; use numeric value or 'inv_sqrt_d_model'.")
|
||||
self.logit_scale = logit_scale
|
||||
|
||||
def get_input_embeddings(self):
|
||||
return self.transformer.wte
|
||||
|
||||
def set_input_embeddings(self, value):
|
||||
self.transformer.wte = value
|
||||
|
||||
def get_output_embeddings(self):
|
||||
return self.transformer.wte
|
||||
|
||||
def set_output_embeddings(self, new_embeddings):
|
||||
self.transformer.wte = new_embeddings
|
||||
|
||||
def set_decoder(self, decoder):
|
||||
self.transformer = decoder
|
||||
|
||||
def get_decoder(self):
|
||||
return self.transformer
|
||||
|
||||
def forward(self, input_ids: torch.LongTensor, past_key_values: Optional[List[Tuple[torch.FloatTensor]]]=None, attention_mask: Optional[torch.ByteTensor]=None, prefix_mask: Optional[torch.ByteTensor]=None, sequence_id: Optional[torch.LongTensor]=None, labels: Optional[torch.LongTensor]=None, return_dict: Optional[bool]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, use_cache: Optional[bool]=None):
|
||||
return_dict = return_dict if return_dict is not None else self.config.return_dict
|
||||
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
||||
outputs = self.transformer(input_ids=input_ids, past_key_values=past_key_values, attention_mask=attention_mask, prefix_mask=prefix_mask, sequence_id=sequence_id, return_dict=return_dict, output_attentions=output_attentions, output_hidden_states=output_hidden_states, use_cache=use_cache)
|
||||
logits = F.linear(outputs.last_hidden_state, self.transformer.wte.weight)
|
||||
if self.logit_scale is not None:
|
||||
if self.logit_scale == 0:
|
||||
warnings.warn(f'Multiplying logits by self.logit_scale={self.logit_scale!r}. This will produce uniform (uninformative) outputs.')
|
||||
logits *= self.logit_scale
|
||||
loss = None
|
||||
if labels is not None:
|
||||
labels = torch.roll(labels, shifts=-1)
|
||||
labels[:, -1] = -100
|
||||
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), labels.to(logits.device).view(-1))
|
||||
return CausalLMOutputWithPast(loss=loss, logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states)
|
||||
|
||||
def param_init_fn(self, module):
|
||||
init_fn_name = self.config.init_config['name']
|
||||
MODEL_INIT_REGISTRY[init_fn_name](module=module, n_layers=self.config.n_layers, d_model=self.config.d_model, **self.config.init_config)
|
||||
|
||||
def fsdp_wrap_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
def activation_checkpointing_fn(self, module):
|
||||
return isinstance(module, MPTBlock)
|
||||
|
||||
def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
|
||||
if inputs_embeds is not None:
|
||||
raise NotImplementedError('inputs_embeds is not implemented for MPT yet')
|
||||
attention_mask = kwargs['attention_mask'].bool()
|
||||
if attention_mask[:, -1].sum() != attention_mask.shape[0]:
|
||||
raise NotImplementedError('MPT does not support generation with right padding.')
|
||||
if self.transformer.attn_uses_sequence_id and self.training:
|
||||
sequence_id = torch.zeros_like(input_ids[:1])
|
||||
else:
|
||||
sequence_id = None
|
||||
if past_key_values is not None:
|
||||
input_ids = input_ids[:, -1].unsqueeze(-1)
|
||||
if self.transformer.prefix_lm:
|
||||
prefix_mask = torch.ones_like(attention_mask)
|
||||
if kwargs.get('use_cache') == False:
|
||||
raise NotImplementedError('MPT with prefix_lm=True does not support use_cache=False.')
|
||||
else:
|
||||
prefix_mask = None
|
||||
return {'input_ids': input_ids, 'attention_mask': attention_mask, 'prefix_mask': prefix_mask, 'sequence_id': sequence_id, 'past_key_values': past_key_values, 'use_cache': kwargs.get('use_cache', True)}
|
||||
|
||||
@staticmethod
|
||||
def _reorder_cache(past_key_values, beam_idx):
|
||||
"""Used by HuggingFace generate when using beam search with kv-caching.
|
||||
|
||||
See https://github.com/huggingface/transformers/blob/3ec7a47664ebe40c40f4b722f6bb1cd30c3821ec/src/transformers/models/gpt2/modeling_gpt2.py#L1122-L1133
|
||||
for an example in transformers.
|
||||
"""
|
||||
reordered_past = []
|
||||
for layer_past in past_key_values:
|
||||
reordered_past += [tuple((past_state.index_select(0, beam_idx) for past_state in layer_past))]
|
||||
return reordered_past
|
||||
@@ -1,56 +0,0 @@
|
||||
import torch
|
||||
|
||||
def _cast_if_autocast_enabled(tensor):
|
||||
if torch.is_autocast_enabled():
|
||||
if tensor.device.type == 'cuda':
|
||||
dtype = torch.get_autocast_gpu_dtype()
|
||||
elif tensor.device.type == 'cpu':
|
||||
dtype = torch.get_autocast_cpu_dtype()
|
||||
else:
|
||||
raise NotImplementedError()
|
||||
return tensor.to(dtype=dtype)
|
||||
return tensor
|
||||
|
||||
class LPLayerNorm(torch.nn.LayerNorm):
|
||||
|
||||
def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True, device=None, dtype=None):
|
||||
super().__init__(normalized_shape=normalized_shape, eps=eps, elementwise_affine=elementwise_affine, device=device, dtype=dtype)
|
||||
|
||||
def forward(self, x):
|
||||
module_device = x.device
|
||||
downcast_x = _cast_if_autocast_enabled(x)
|
||||
downcast_weight = _cast_if_autocast_enabled(self.weight) if self.weight is not None else self.weight
|
||||
downcast_bias = _cast_if_autocast_enabled(self.bias) if self.bias is not None else self.bias
|
||||
with torch.autocast(enabled=False, device_type=module_device.type):
|
||||
return torch.nn.functional.layer_norm(downcast_x, self.normalized_shape, downcast_weight, downcast_bias, self.eps)
|
||||
|
||||
def rms_norm(x, weight=None, eps=1e-05):
|
||||
output = x / torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
|
||||
if weight is not None:
|
||||
return output * weight
|
||||
return output
|
||||
|
||||
class RMSNorm(torch.nn.Module):
|
||||
|
||||
def __init__(self, normalized_shape, eps=1e-05, weight=True, dtype=None, device=None):
|
||||
super().__init__()
|
||||
self.eps = eps
|
||||
if weight:
|
||||
self.weight = torch.nn.Parameter(torch.ones(normalized_shape, dtype=dtype, device=device))
|
||||
else:
|
||||
self.register_parameter('weight', None)
|
||||
|
||||
def forward(self, x):
|
||||
return rms_norm(x.float(), self.weight, self.eps).to(dtype=x.dtype)
|
||||
|
||||
class LPRMSNorm(RMSNorm):
|
||||
|
||||
def __init__(self, normalized_shape, eps=1e-05, weight=True, dtype=None, device=None):
|
||||
super().__init__(normalized_shape=normalized_shape, eps=eps, weight=weight, dtype=dtype, device=device)
|
||||
|
||||
def forward(self, x):
|
||||
downcast_x = _cast_if_autocast_enabled(x)
|
||||
downcast_weight = _cast_if_autocast_enabled(self.weight) if self.weight is not None else self.weight
|
||||
with torch.autocast(enabled=False, device_type=x.device.type):
|
||||
return rms_norm(downcast_x, downcast_weight, self.eps).to(dtype=x.dtype)
|
||||
NORM_CLASS_REGISTRY = {'layernorm': torch.nn.LayerNorm, 'low_precision_layernorm': LPLayerNorm, 'rmsnorm': RMSNorm, 'low_precision_rmsnorm': LPRMSNorm}
|
||||
@@ -1,181 +0,0 @@
|
||||
import math
|
||||
import warnings
|
||||
from collections.abc import Sequence
|
||||
from functools import partial
|
||||
from typing import Optional, Tuple, Union
|
||||
import torch
|
||||
from torch import nn
|
||||
from .norm import NORM_CLASS_REGISTRY
|
||||
|
||||
def torch_default_param_init_fn_(module: nn.Module, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f"Initializing network using module's reset_parameters attribute")
|
||||
if hasattr(module, 'reset_parameters'):
|
||||
module.reset_parameters()
|
||||
|
||||
def fused_init_helper_(module: nn.Module, init_fn_):
|
||||
_fused = getattr(module, '_fused', None)
|
||||
if _fused is None:
|
||||
raise RuntimeError(f'Internal logic error')
|
||||
(dim, splits) = _fused
|
||||
splits = (0, *splits, module.weight.size(dim))
|
||||
for (s, e) in zip(splits[:-1], splits[1:]):
|
||||
slice_indices = [slice(None)] * module.weight.ndim
|
||||
slice_indices[dim] = slice(s, e)
|
||||
init_fn_(module.weight[slice_indices])
|
||||
|
||||
def generic_param_init_fn_(module: nn.Module, init_fn_, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f'If model has bias parameters they are initialized to 0.')
|
||||
init_div_is_residual = init_div_is_residual
|
||||
if init_div_is_residual is False:
|
||||
div_is_residual = 1.0
|
||||
elif init_div_is_residual is True:
|
||||
div_is_residual = math.sqrt(2 * n_layers)
|
||||
elif isinstance(init_div_is_residual, float) or isinstance(init_div_is_residual, int):
|
||||
div_is_residual = init_div_is_residual
|
||||
elif isinstance(init_div_is_residual, str) and init_div_is_residual.isnumeric():
|
||||
div_is_residual = float(init_div_is_residual)
|
||||
else:
|
||||
div_is_residual = 1.0
|
||||
raise ValueError(f'Expected init_div_is_residual to be boolean or numeric, got {init_div_is_residual}')
|
||||
if init_div_is_residual is not False:
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Initializing _is_residual layers then dividing them by {div_is_residual:.3f}. ' + f'Set `init_div_is_residual: false` in init config to disable this.')
|
||||
if isinstance(module, nn.Linear):
|
||||
if hasattr(module, '_fused'):
|
||||
fused_init_helper_(module, init_fn_)
|
||||
else:
|
||||
init_fn_(module.weight)
|
||||
if module.bias is not None:
|
||||
torch.nn.init.zeros_(module.bias)
|
||||
if init_div_is_residual is not False and getattr(module, '_is_residual', False):
|
||||
with torch.no_grad():
|
||||
module.weight.div_(div_is_residual)
|
||||
elif isinstance(module, nn.Embedding):
|
||||
if emb_init_std is not None:
|
||||
std = emb_init_std
|
||||
if std == 0:
|
||||
warnings.warn(f'Embedding layer initialized to 0.')
|
||||
emb_init_fn_ = partial(torch.nn.init.normal_, mean=0.0, std=std)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Embedding layer initialized using normal distribution with mean=0 and std={std!r}.')
|
||||
elif emb_init_uniform_lim is not None:
|
||||
lim = emb_init_uniform_lim
|
||||
if isinstance(lim, Sequence):
|
||||
if len(lim) > 2:
|
||||
raise ValueError(f'Uniform init requires a min and a max limit. User input: {lim}.')
|
||||
if lim[0] == lim[1]:
|
||||
warnings.warn(f'Embedding layer initialized to {lim[0]}.')
|
||||
else:
|
||||
if lim == 0:
|
||||
warnings.warn(f'Embedding layer initialized to 0.')
|
||||
lim = [-lim, lim]
|
||||
(a, b) = lim
|
||||
emb_init_fn_ = partial(torch.nn.init.uniform_, a=a, b=b)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Embedding layer initialized using uniform distribution in range {lim}.')
|
||||
else:
|
||||
emb_init_fn_ = init_fn_
|
||||
emb_init_fn_(module.weight)
|
||||
elif isinstance(module, tuple(set(NORM_CLASS_REGISTRY.values()))):
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Norm weights are set to 1. If norm layer has a bias it is initialized to 0.')
|
||||
if hasattr(module, 'weight') and module.weight is not None:
|
||||
torch.nn.init.ones_(module.weight)
|
||||
if hasattr(module, 'bias') and module.bias is not None:
|
||||
torch.nn.init.zeros_(module.bias)
|
||||
elif isinstance(module, nn.MultiheadAttention):
|
||||
if module._qkv_same_embed_dim:
|
||||
assert module.in_proj_weight is not None
|
||||
assert module.q_proj_weight is None and module.k_proj_weight is None and (module.v_proj_weight is None)
|
||||
assert d_model is not None
|
||||
_d = d_model
|
||||
splits = (0, _d, 2 * _d, 3 * _d)
|
||||
for (s, e) in zip(splits[:-1], splits[1:]):
|
||||
init_fn_(module.in_proj_weight[s:e])
|
||||
else:
|
||||
assert module.q_proj_weight is not None and module.k_proj_weight is not None and (module.v_proj_weight is not None)
|
||||
assert module.in_proj_weight is None
|
||||
init_fn_(module.q_proj_weight)
|
||||
init_fn_(module.k_proj_weight)
|
||||
init_fn_(module.v_proj_weight)
|
||||
if module.in_proj_bias is not None:
|
||||
torch.nn.init.zeros_(module.in_proj_bias)
|
||||
if module.bias_k is not None:
|
||||
torch.nn.init.zeros_(module.bias_k)
|
||||
if module.bias_v is not None:
|
||||
torch.nn.init.zeros_(module.bias_v)
|
||||
init_fn_(module.out_proj.weight)
|
||||
if init_div_is_residual is not False and getattr(module.out_proj, '_is_residual', False):
|
||||
with torch.no_grad():
|
||||
module.out_proj.weight.div_(div_is_residual)
|
||||
if module.out_proj.bias is not None:
|
||||
torch.nn.init.zeros_(module.out_proj.bias)
|
||||
else:
|
||||
for _ in module.parameters(recurse=False):
|
||||
raise NotImplementedError(f'{module.__class__.__name__} parameters are not initialized by param_init_fn.')
|
||||
|
||||
def _normal_init_(std, mean=0.0):
|
||||
return partial(torch.nn.init.normal_, mean=mean, std=std)
|
||||
|
||||
def _normal_param_init_fn_(module: nn.Module, std: float, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
init_fn_ = _normal_init_(std=std)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using torch.nn.init.normal_ init fn mean=0.0, std={std}')
|
||||
generic_param_init_fn_(module=module, init_fn_=init_fn_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def baseline_param_init_fn_(module: nn.Module, init_std: float, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if init_std is None:
|
||||
raise ValueError("You must set model.init_config['init_std'] to a float value to use the default initialization scheme.")
|
||||
_normal_param_init_fn_(module=module, std=init_std, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def small_param_init_fn_(module: nn.Module, n_layers: int, d_model: int, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
std = math.sqrt(2 / (5 * d_model))
|
||||
_normal_param_init_fn_(module=module, std=std, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def neox_param_init_fn_(module: nn.Module, n_layers: int, d_model: int, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, verbose: int=0, **kwargs):
|
||||
"""From section 2.3.1 of GPT-NeoX-20B:
|
||||
|
||||
An Open-Source AutoregressiveLanguage Model — Black et. al. (2022)
|
||||
see https://github.com/EleutherAI/gpt-neox/blob/9610391ab319403cef079b438edd016a2443af54/megatron/model/init_functions.py#L151
|
||||
and https://github.com/EleutherAI/gpt-neox/blob/main/megatron/model/transformer.py
|
||||
"""
|
||||
del kwargs
|
||||
residual_div = n_layers / math.sqrt(10)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'setting init_div_is_residual to {residual_div}')
|
||||
small_param_init_fn_(module=module, d_model=d_model, n_layers=n_layers, init_div_is_residual=residual_div, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def kaiming_uniform_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, fan_mode: str='fan_in', init_nonlinearity: str='leaky_relu', verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using nn.init.kaiming_uniform_ init fn with parameters: ' + f'a={init_gain}, mode={fan_mode}, nonlinearity={init_nonlinearity}')
|
||||
kaiming_uniform_ = partial(nn.init.kaiming_uniform_, a=init_gain, mode=fan_mode, nonlinearity=init_nonlinearity)
|
||||
generic_param_init_fn_(module=module, init_fn_=kaiming_uniform_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def kaiming_normal_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, fan_mode: str='fan_in', init_nonlinearity: str='leaky_relu', verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using nn.init.kaiming_normal_ init fn with parameters: ' + f'a={init_gain}, mode={fan_mode}, nonlinearity={init_nonlinearity}')
|
||||
kaiming_normal_ = partial(torch.nn.init.kaiming_normal_, a=init_gain, mode=fan_mode, nonlinearity=init_nonlinearity)
|
||||
generic_param_init_fn_(module=module, init_fn_=kaiming_normal_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def xavier_uniform_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, verbose: int=0, **kwargs):
|
||||
del kwargs
|
||||
xavier_uniform_ = partial(torch.nn.init.xavier_uniform_, gain=init_gain)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using torch.nn.init.xavier_uniform_ init fn with parameters: ' + f'gain={init_gain}')
|
||||
generic_param_init_fn_(module=module, init_fn_=xavier_uniform_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
|
||||
def xavier_normal_param_init_fn_(module: nn.Module, n_layers: int, d_model: Optional[int]=None, init_div_is_residual: Union[int, float, str, bool]=True, emb_init_std: Optional[float]=None, emb_init_uniform_lim: Optional[Union[Tuple[float, float], float]]=None, init_gain: float=0, verbose: int=0, **kwargs):
|
||||
xavier_normal_ = partial(torch.nn.init.xavier_normal_, gain=init_gain)
|
||||
if verbose > 1:
|
||||
warnings.warn(f'Using torch.nn.init.xavier_normal_ init fn with parameters: ' + f'gain={init_gain}')
|
||||
generic_param_init_fn_(module=module, init_fn_=xavier_normal_, d_model=d_model, n_layers=n_layers, init_div_is_residual=init_div_is_residual, emb_init_std=emb_init_std, emb_init_uniform_lim=emb_init_uniform_lim, verbose=verbose)
|
||||
MODEL_INIT_REGISTRY = {'default_': torch_default_param_init_fn_, 'baseline_': baseline_param_init_fn_, 'kaiming_uniform_': kaiming_uniform_param_init_fn_, 'kaiming_normal_': kaiming_normal_param_init_fn_, 'neox_init_': neox_param_init_fn_, 'small_init_': small_param_init_fn_, 'xavier_uniform_': xavier_uniform_param_init_fn_, 'xavier_normal_': xavier_normal_param_init_fn_}
|
||||
@@ -1,46 +0,0 @@
|
||||
import torch
|
||||
from llava.model import *
|
||||
from transformers import AutoConfig, StoppingCriteria
|
||||
|
||||
|
||||
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)
|
||||
|
||||
|
||||
|
||||
class KeywordsStoppingCriteria(StoppingCriteria):
|
||||
def __init__(self, keywords, tokenizer, input_ids):
|
||||
self.keywords = keywords
|
||||
self.keyword_ids = [tokenizer(keyword).input_ids for keyword in keywords]
|
||||
self.keyword_ids = [keyword_id[0] for keyword_id in self.keyword_ids if type(keyword_id) is list and len(keyword_id) == 1]
|
||||
self.tokenizer = tokenizer
|
||||
self.start_len = None
|
||||
self.input_ids = input_ids
|
||||
|
||||
def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
|
||||
if self.start_len is None:
|
||||
self.start_len = self.input_ids.shape[1]
|
||||
else:
|
||||
for keyword_id in self.keyword_ids:
|
||||
if output_ids[0, -1] == keyword_id:
|
||||
return True
|
||||
outputs = self.tokenizer.batch_decode(output_ids[:, self.start_len:], skip_special_tokens=True)[0]
|
||||
for keyword in self.keywords:
|
||||
if keyword in outputs:
|
||||
return True
|
||||
return False
|
||||
@@ -1,153 +0,0 @@
|
||||
"""
|
||||
Usage:
|
||||
python3 -m fastchat.serve.cli --model ~/model_weights/llama-7b
|
||||
"""
|
||||
import argparse
|
||||
import time
|
||||
|
||||
import torch
|
||||
from transformers import AutoTokenizer, AutoModelForCausalLM
|
||||
|
||||
from llava.conversation import conv_templates, SeparatorStyle
|
||||
|
||||
|
||||
@torch.inference_mode()
|
||||
def generate_stream(tokenizer, model, params, device,
|
||||
context_len=2048, stream_interval=2):
|
||||
"""Adapted from fastchat/serve/model_worker.py::generate_stream"""
|
||||
|
||||
prompt = params["prompt"]
|
||||
l_prompt = len(prompt)
|
||||
temperature = float(params.get("temperature", 1.0))
|
||||
max_new_tokens = int(params.get("max_new_tokens", 256))
|
||||
stop_str = params.get("stop", None)
|
||||
|
||||
input_ids = tokenizer(prompt).input_ids
|
||||
output_ids = list(input_ids)
|
||||
|
||||
max_src_len = context_len - max_new_tokens - 8
|
||||
input_ids = input_ids[-max_src_len:]
|
||||
|
||||
for i in range(max_new_tokens):
|
||||
if i == 0:
|
||||
out = model(
|
||||
torch.as_tensor([input_ids], device=device), use_cache=True)
|
||||
logits = out.logits
|
||||
past_key_values = out.past_key_values
|
||||
else:
|
||||
attention_mask = torch.ones(
|
||||
1, past_key_values[0][0].shape[-2] + 1, device=device)
|
||||
out = model(input_ids=torch.as_tensor([[token]], device=device),
|
||||
use_cache=True,
|
||||
attention_mask=attention_mask,
|
||||
past_key_values=past_key_values)
|
||||
logits = out.logits
|
||||
past_key_values = out.past_key_values
|
||||
|
||||
last_token_logits = logits[0][-1]
|
||||
if temperature < 1e-4:
|
||||
token = int(torch.argmax(last_token_logits))
|
||||
else:
|
||||
probs = torch.softmax(last_token_logits / temperature, dim=-1)
|
||||
token = int(torch.multinomial(probs, num_samples=1))
|
||||
|
||||
output_ids.append(token)
|
||||
|
||||
if token == tokenizer.eos_token_id:
|
||||
stopped = True
|
||||
else:
|
||||
stopped = False
|
||||
|
||||
if i % stream_interval == 0 or i == max_new_tokens - 1 or stopped:
|
||||
output = tokenizer.decode(output_ids, skip_special_tokens=True)
|
||||
pos = output.rfind(stop_str, l_prompt)
|
||||
if pos != -1:
|
||||
output = output[:pos]
|
||||
stopped = True
|
||||
yield output
|
||||
|
||||
if stopped:
|
||||
break
|
||||
|
||||
del past_key_values
|
||||
|
||||
|
||||
def main(args):
|
||||
model_name = args.model_name
|
||||
num_gpus = args.num_gpus
|
||||
|
||||
# Model
|
||||
if args.device == "cuda":
|
||||
kwargs = {"torch_dtype": torch.float16}
|
||||
if num_gpus == "auto":
|
||||
kwargs["device_map"] = "auto"
|
||||
else:
|
||||
num_gpus = int(num_gpus)
|
||||
if num_gpus != 1:
|
||||
kwargs.update({
|
||||
"device_map": "auto",
|
||||
"max_memory": {i: "13GiB" for i in range(num_gpus)},
|
||||
})
|
||||
elif args.device == "cpu":
|
||||
kwargs = {}
|
||||
else:
|
||||
raise ValueError(f"Invalid device: {args.device}")
|
||||
|
||||
tokenizer = AutoTokenizer.from_pretrained(model_name)
|
||||
model = AutoModelForCausalLM.from_pretrained(model_name,
|
||||
low_cpu_mem_usage=True, **kwargs)
|
||||
|
||||
if args.device == "cuda" and num_gpus == 1:
|
||||
model.cuda()
|
||||
|
||||
# Chat
|
||||
conv = conv_templates[args.conv_template].copy()
|
||||
while True:
|
||||
try:
|
||||
inp = input(f"{conv.roles[0]}: ")
|
||||
except EOFError:
|
||||
inp = ""
|
||||
if not inp:
|
||||
print("exit...")
|
||||
break
|
||||
|
||||
conv.append_message(conv.roles[0], inp)
|
||||
conv.append_message(conv.roles[1], None)
|
||||
prompt = conv.get_prompt()
|
||||
|
||||
params = {
|
||||
"model": model_name,
|
||||
"prompt": prompt,
|
||||
"temperature": args.temperature,
|
||||
"max_new_tokens": args.max_new_tokens,
|
||||
"stop": conv.sep if conv.sep_style == SeparatorStyle.SINGLE else conv.sep2,
|
||||
}
|
||||
|
||||
print(f"{conv.roles[1]}: ", end="", flush=True)
|
||||
pre = 0
|
||||
for outputs in generate_stream(tokenizer, model, params, args.device):
|
||||
outputs = outputs[len(prompt) + 1:].strip()
|
||||
outputs = outputs.split(" ")
|
||||
now = len(outputs)
|
||||
if now - 1 > pre:
|
||||
print(" ".join(outputs[pre:now-1]), end=" ", flush=True)
|
||||
pre = now - 1
|
||||
print(" ".join(outputs[pre:]), flush=True)
|
||||
|
||||
conv.messages[-1][-1] = " ".join(outputs)
|
||||
|
||||
if args.debug:
|
||||
print("\n", {"prompt": prompt, "outputs": outputs}, "\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
|
||||
parser.add_argument("--num-gpus", type=str, default="1")
|
||||
parser.add_argument("--device", type=str, choices=["cuda", "cpu"], default="cuda")
|
||||
parser.add_argument("--conv-template", type=str, default="v1")
|
||||
parser.add_argument("--temperature", type=float, default=0.7)
|
||||
parser.add_argument("--max-new-tokens", type=int, default=512)
|
||||
parser.add_argument("--debug", action="store_true")
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
@@ -1,298 +0,0 @@
|
||||
"""
|
||||
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")
|
||||
@@ -1,73 +0,0 @@
|
||||
code_highlight_css = (
|
||||
"""
|
||||
#chatbot .hll { background-color: #ffffcc }
|
||||
#chatbot .c { color: #408080; font-style: italic }
|
||||
#chatbot .err { border: 1px solid #FF0000 }
|
||||
#chatbot .k { color: #008000; font-weight: bold }
|
||||
#chatbot .o { color: #666666 }
|
||||
#chatbot .ch { color: #408080; font-style: italic }
|
||||
#chatbot .cm { color: #408080; font-style: italic }
|
||||
#chatbot .cp { color: #BC7A00 }
|
||||
#chatbot .cpf { color: #408080; font-style: italic }
|
||||
#chatbot .c1 { color: #408080; font-style: italic }
|
||||
#chatbot .cs { color: #408080; font-style: italic }
|
||||
#chatbot .gd { color: #A00000 }
|
||||
#chatbot .ge { font-style: italic }
|
||||
#chatbot .gr { color: #FF0000 }
|
||||
#chatbot .gh { color: #000080; font-weight: bold }
|
||||
#chatbot .gi { color: #00A000 }
|
||||
#chatbot .go { color: #888888 }
|
||||
#chatbot .gp { color: #000080; font-weight: bold }
|
||||
#chatbot .gs { font-weight: bold }
|
||||
#chatbot .gu { color: #800080; font-weight: bold }
|
||||
#chatbot .gt { color: #0044DD }
|
||||
#chatbot .kc { color: #008000; font-weight: bold }
|
||||
#chatbot .kd { color: #008000; font-weight: bold }
|
||||
#chatbot .kn { color: #008000; font-weight: bold }
|
||||
#chatbot .kp { color: #008000 }
|
||||
#chatbot .kr { color: #008000; font-weight: bold }
|
||||
#chatbot .kt { color: #B00040 }
|
||||
#chatbot .m { color: #666666 }
|
||||
#chatbot .s { color: #BA2121 }
|
||||
#chatbot .na { color: #7D9029 }
|
||||
#chatbot .nb { color: #008000 }
|
||||
#chatbot .nc { color: #0000FF; font-weight: bold }
|
||||
#chatbot .no { color: #880000 }
|
||||
#chatbot .nd { color: #AA22FF }
|
||||
#chatbot .ni { color: #999999; font-weight: bold }
|
||||
#chatbot .ne { color: #D2413A; font-weight: bold }
|
||||
#chatbot .nf { color: #0000FF }
|
||||
#chatbot .nl { color: #A0A000 }
|
||||
#chatbot .nn { color: #0000FF; font-weight: bold }
|
||||
#chatbot .nt { color: #008000; font-weight: bold }
|
||||
#chatbot .nv { color: #19177C }
|
||||
#chatbot .ow { color: #AA22FF; font-weight: bold }
|
||||
#chatbot .w { color: #bbbbbb }
|
||||
#chatbot .mb { color: #666666 }
|
||||
#chatbot .mf { color: #666666 }
|
||||
#chatbot .mh { color: #666666 }
|
||||
#chatbot .mi { color: #666666 }
|
||||
#chatbot .mo { color: #666666 }
|
||||
#chatbot .sa { color: #BA2121 }
|
||||
#chatbot .sb { color: #BA2121 }
|
||||
#chatbot .sc { color: #BA2121 }
|
||||
#chatbot .dl { color: #BA2121 }
|
||||
#chatbot .sd { color: #BA2121; font-style: italic }
|
||||
#chatbot .s2 { color: #BA2121 }
|
||||
#chatbot .se { color: #BB6622; font-weight: bold }
|
||||
#chatbot .sh { color: #BA2121 }
|
||||
#chatbot .si { color: #BB6688; font-weight: bold }
|
||||
#chatbot .sx { color: #008000 }
|
||||
#chatbot .sr { color: #BB6688 }
|
||||
#chatbot .s1 { color: #BA2121 }
|
||||
#chatbot .ss { color: #19177C }
|
||||
#chatbot .bp { color: #008000 }
|
||||
#chatbot .fm { color: #0000FF }
|
||||
#chatbot .vc { color: #19177C }
|
||||
#chatbot .vg { color: #19177C }
|
||||
#chatbot .vi { color: #19177C }
|
||||
#chatbot .vm { color: #19177C }
|
||||
#chatbot .il { color: #666666 }
|
||||
""")
|
||||
#.highlight { background: #f8f8f8; }
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user