Upload generation_multi.py with huggingface_hub

generation_multi.py

@@ -0,0 +1,551 @@
+# Copyright 2024 AllenAI. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+#import openai
+import asyncio
+import copy
+import json
+import os
+import sys
+import time
+from collections import defaultdict
+from dataclasses import asdict, dataclass
+from pprint import pformat
+from typing import Dict, List, Optional
+
+from huggingface_hub import HfApi
+from huggingface_hub.repocard import RepoCard
+from rich.pretty import pprint
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+from open_instruct.dataset_processor import (
+    INPUT_IDS_PROMPT_KEY,
+    DatasetConfig,
+    SFTDatasetProcessor,
+)
+from open_instruct.rejection_sampling.api_generate_multi import (  # Import your classes
+    LLMGenerationConfig,
+    LLMProcessor,
+)
+'''from open_instruct.rejection_sampling.claude_api_generate import (  # Import your classes
+    ClaudeGenerationConfig,
+    ClaudeProcessor,
+)'''
+from open_instruct.utils import ArgumentParserPlus, combine_dataset
+
+api = HfApi()
+# we don't use `multiprocessing.cpu_count()` because typically we only have 12 CPUs
+# and that the shards might be small
+NUM_CPUS_FOR_DATASET_MAP = 4
+
+
+@dataclass
+class Args:
+    dataset_mixer_list: List[str]
+    dataset_splits: List[str] = None
+    dataset_start_idx: int = 0
+    dataset_end_idx: Optional[int] = None
+
+    model_name_or_path: str = "cleanrl/EleutherAI_pythia-6.9b-deduped__sft__tldr"#"gpt-3.5-turbo-0125"
+    revision: str = "main"
+    save_filename: str = "completions.jsonl"
+    skill: str = "chat"
+    mode: str = "generation"  # Can be "generation" or "judgment"
+    
+    num_turns: int = 1
+    mt_token_cutoff: int = 8000
+    model2_name_or_path: str = "cleanrl/EleutherAI_pythia-6.9b-deduped__sft__tldr"#"gpt-3.5-turbo-0125"
+    revision2: str = "main"
+
+    # upload config
+    hf_repo_id: str = os.path.basename(__file__)[: -len(".py")]
+    push_to_hub: bool = False
+    hf_entity: Optional[str] = None
+    add_timestamp: bool = True
+
+
+@dataclass
+class GenerationArgs:
+    num_completions: int = 3
+    temperature: float = 0.8
+    response_length: int = 2048
+    top_p: float = 0.9
+    tensor_parallel_size: int = 1
+
+
+def save_jsonl(save_filename: str, table: Dict[str, List]):
+    first_key = list(table.keys())[0]
+    os.makedirs(os.path.dirname(save_filename), exist_ok=True)
+    print("About to save", os.path.dirname(save_filename))
+    with open(save_filename, "w") as outfile:
+        for i in range(len(table[first_key])):
+            json.dump({key: table[key][i] for key in table}, outfile)
+            outfile.write("\n")
+
+
+async def generate_with_openai(model_name: str, data_list: list, args: Args, gen_args: GenerationArgs):
+    config = LLMGenerationConfig(model=model_name, num_completions=gen_args.num_completions)
+    processor = LLMProcessor(config)
+    results = await processor.process_batch(data_list, args, gen_args)
+    return results
+
+async def generate_with_claude(model_name: str, data_list: list, args: Args, gen_args: GenerationArgs):
+    return
+    '''config = ClaudeGenerationConfig(model=model_name, num_completions=gen_args.num_completions)
+    processor = ClaudeProcessor(config)
+    results = await processor.process_batch(data_list, args, gen_args)
+    return results'''
+
+
+def generate_with_vllm(model_name_or_path: str, revision: str, prompt_token_ids: List[int], gen_args: GenerationArgs):
+    llm = LLM(
+        model=model_name_or_path,
+        revision=revision,
+        tokenizer_revision=revision,
+        tensor_parallel_size=gen_args.tensor_parallel_size,
+        max_model_len=gen_args.response_length,
+    )
+
+    # filter out prompts which are beyond the model's max token length
+    max_model_len = llm.llm_engine.scheduler_config.max_model_len
+    prompt_token_ids_len = len(prompt_token_ids)
+    prompt_token_ids = [item for item in prompt_token_ids if len(item) < max_model_len]
+    if len(prompt_token_ids) != prompt_token_ids_len:
+        print(f"Filtered out {prompt_token_ids_len - len(prompt_token_ids)} prompts which exceeds max token length")
+
+    outputs = llm.generate(
+        prompt_token_ids=prompt_token_ids,
+        sampling_params=SamplingParams(
+            n=gen_args.num_completions,
+            temperature=gen_args.temperature,
+            top_p=1.0,
+            max_tokens=gen_args.response_length,
+            include_stop_str_in_output=True,
+        ),
+    )
+
+    return [
+        {
+            "outputs": [asdict(out) for out in output.outputs],
+            "prompt": output.prompt,
+            "prompt_logprobs": output.prompt_logprobs,
+            "metrics": output.metrics,
+        }
+        for output in outputs
+    ]
+
+
+def format_conversation(messages: list) -> str:
+    formatted_conversation = []
+
+    # Iterate through the messages
+    for message in messages:  # Exclude the last assistant message
+        role = "User B" if message["role"] == "assistant" else "User A"   # system should be User A
+        content = message["content"].strip()
+        formatted_conversation.append(f"{role}: {content}")
+
+    # Join the conversation with a single newline
+    return "\n".join(formatted_conversation)
+    
+def extract_user_turn(example):
+   #print(example['messages'])
+   msgs = example['messages']
+   out = []
+   for msg in msgs:
+      out.append(msg)
+      if msg['role'] == 'assistant':
+         break
+   example['messages'] = out
+   #print(example['messages'])
+   #exit()
+   return example
+
+def get_max_model_len(model_name_or_path, revision, gen_args):
+    llm = LLM(
+        model=model_name_or_path,
+        revision=revision,
+        tokenizer_revision=revision,
+        tensor_parallel_size=gen_args.tensor_parallel_size,
+        max_model_len=gen_args.response_length,
+    )
+    return llm.llm_engine.scheduler_config.max_model_len
+
+def main(args: Args, dataset_config: DatasetConfig, gen_args: GenerationArgs):
+    dataset = combine_dataset(
+        args.dataset_mixer_list,
+        splits=args.dataset_splits,
+        columns_to_keep=[dataset_config.sft_messages_key],
+    )
+    if args.dataset_end_idx is None:
+        args.dataset_end_idx = len(dataset)
+    dataset = dataset.select(range(args.dataset_start_idx, args.dataset_end_idx))
+    pprint([dataset_config, args, gen_args])
+
+    num_completions = gen_args.num_completions
+    if args.num_turns>1:
+        gen_args.num_completions = 1
+        
+        # cut off later turns to get consistent num_turns
+        dataset = dataset.map(extract_user_turn)
+        
+    if "gpt-3.5" in args.model_name_or_path or "gpt-4" in args.model_name_or_path:
+        #try:
+        dataset_gpt = dataset.map(
+            lambda x: {"prompt": format_conversation(x["messages"][:-1])},
+            num_proc=NUM_CPUS_FOR_DATASET_MAP,
+        )
+        messages = dataset_gpt["prompt"]
+        responses, _ = asyncio.run(generate_with_openai(args.model_name_or_path, messages, args, gen_args))
+        outputs = [{"outputs": [{"text": r} for r in response]} for response in responses]
+        '''except openai.BadRequestError as e:
+            print(f"OpenAI BAD REQUEST error {e.status_code}: (e.response)")
+            outputs = [{"outputs": [{"text": ''}]} for i in dataset["messages"]]'''
+    elif "claude" in args.model_name_or_path:
+        dataset_claude = dataset.map(
+            lambda x: {"prompt": format_conversation(x["messages"][:-1])},
+            num_proc=NUM_CPUS_FOR_DATASET_MAP,
+        )
+        messages = dataset_claude["prompt"]
+        responses, _ = asyncio.run(generate_with_claude(args.model_name_or_path, messages, args, gen_args))
+        outputs = [{"outputs": [{"text": r} for r in response]} for response in responses]
+    else:
+        tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, revision=args.revision)
+        dataset_processor = SFTDatasetProcessor(tokenizer=tokenizer, config=dataset_config)
+        dataset = dataset_processor.tokenize(dataset)
+        dataset = dataset_processor.filter(dataset)
+        prompt_token_ids = dataset[INPUT_IDS_PROMPT_KEY]
+        outputs = generate_with_vllm(args.model_name_or_path, args.revision, prompt_token_ids, gen_args)
+        
+    # Assuming we generate n=3 completions per prompt; the outputs will look like:
+    # prompt | completions
+    # -------|------------
+    # q1     | a1
+    # q1     | a2
+    # q1     | a3
+    # q2     | a1
+    # ...
+        
+    #print(dataset["messages"][0])
+    print('check 1')
+        
+    table = defaultdict(list)
+    num_prompt_with_identical_completions = 0
+    print(len(outputs), len(dataset["messages"]), len(outputs[0]["outputs"]))
+    for output, messages in zip(outputs, dataset["messages"]):
+        # if the model completions are exactly the same across all completions per prompt, we can skip this
+        if len(set(tuple(item["text"]) for item in output["outputs"])) == 1 and gen_args.num_completions!=1:
+            num_prompt_with_identical_completions += 1
+            continue
+
+        for item in output["outputs"]:
+            #messages = dataset["messages"][msg_ind]
+            new_messages = copy.deepcopy(messages[:-1])
+            new_messages.append({"role": "assistant", "content": item["text"]})
+            table["messages"].append(new_messages)
+            table["model_completion"].append(item["text"])
+            table["reference_completion"].append(messages[-1]["content"])
+            
+            #dataset["messages"][msg_ind] = new_messages
+            dataset = dataset.add_item({'messages': new_messages})
+            
+            #print(msg_ind, new_messages)
+            #input()
+        dataset = dataset.select(range(1,len(dataset)))
+
+    print(f"Number prompts with identical completions: {num_prompt_with_identical_completions}")
+           
+    print(len(dataset["messages"]))
+    #print(dataset["messages"][0])
+    #dataset["messages"][0][0]['content']
+    print('check 2')
+           
+    prompt_for_user = 'Pretend you are the user in this conversation. Follow up on our conversation so far by asking for clarification. Please ensure that you give a clear and concise request. Try to make your request diverse and interesting. Use the format "User: [request]"'
+    table = defaultdict(list)
+    max_model_len1 = 6000
+    max_model_len2 = 6000
+    if args.num_turns>1:
+       if "gpt-3.5" not in args.model_name_or_path and "gpt-4" not in args.model_name_or_path:
+           max_model_len1 = get_max_model_len(args.model_name_or_path, args.revision, gen_args)
+       if "gpt-3.5" not in args.model2_name_or_path and "gpt-4" not in args.model2_name_or_path:
+           max_model_len2 = get_max_model_len(args.model2_name_or_path, args.revision2, gen_args)
+    for turn in range(args.num_turns-1):
+       #once = True
+       for messages in dataset["messages"]:
+           new_messages = copy.deepcopy(messages)
+           #if once:
+           new_messages.append({"role": "user", "content": prompt_for_user})
+           #    once = False
+           #else:
+           #    new_messages.append({"role": "user", "content": longlonglong})
+           #dataset["messages"][msg_ind] = new_messages
+           #dataset["messages"][msg_ind].append({"role": "user", "content": prompt_for_user})
+           dataset = dataset.add_item({'messages': new_messages})
+           dataset = dataset.select(range(1,len(dataset)))
+       
+       #print(dataset["messages"][0])
+       print('check 3')
+       
+       # "User" turn
+       finished_convs = set()
+       if "gpt-3.5" in args.model2_name_or_path or "gpt-4" in args.model2_name_or_path:
+           #try:
+           dataset_gpt = dataset.map(
+               lambda x: {"prompt": format_conversation(x["messages"])},#[:-1])},
+               num_proc=NUM_CPUS_FOR_DATASET_MAP,
+           )
+           messages = dataset_gpt["prompt"]
+           responses, finished_convs = asyncio.run(generate_with_openai(args.model2_name_or_path, messages, args, gen_args))
+           outputs = [{"outputs": [{"text": r} for r in response]} for response in responses]
+           #outputs = [{"outputs": [{"text": response} for response in responses]}]
+           '''except openai.BadRequestError as e:
+                print(f"OpenAI BAD REQUEST error {e.status_code}: (e.response)")
+                outputs = [{"outputs": [{"text": ''}]} for i in dataset["messages"]]
+                break'''
+       elif "claude" in args.model_name_or_path:
+           dataset_claude = dataset.map(
+               lambda x: {"prompt": format_conversation(x["messages"][:-1])},
+               num_proc=NUM_CPUS_FOR_DATASET_MAP,
+           )
+           messages = dataset_claude["prompt"]
+           responses, _ = asyncio.run(generate_with_claude(args.model_name_or_path, messages, args, gen_args))
+           outputs = [{"outputs": [{"text": r} for r in response]} for response in responses]
+   
+       else:
+           tokenizer = AutoTokenizer.from_pretrained(args.model2_name_or_path, revision=args.revision2)
+           dataset_processor = SFTDatasetProcessor(tokenizer=tokenizer, config=dataset_config)
+           dataset = dataset_processor.tokenize(dataset)
+           dataset = dataset_processor.filter(dataset)
+           prompt_token_ids = dataset[INPUT_IDS_PROMPT_KEY]
+      
+           # filter out prompts which are beyond the model's max token length
+           prompt_token_ids_len = len(prompt_token_ids)
+           prompt_token_ids_new = []
+           for i, item in enumerate(prompt_token_ids):
+               if len(item) < max_model_len2:
+                   prompt_token_ids_new.append(item)
+               else:
+                   print('EXCEED!!!!!!!!!!!', len(item), max_model_len2)
+                   finished_convs.add(i)
+           if len(prompt_token_ids_new) != prompt_token_ids_len:
+              print(f"Filtered out {prompt_token_ids_len - len(prompt_token_ids_new)} prompts which exceeds max token length")
+           if len(prompt_token_ids_new)==0:
+               for i, messages in enumerate(dataset["messages"]):
+                   dataset = dataset.add_item({'messages': messages[:-1]})
+                   dataset = dataset.select(range(1,len(dataset)))
+               break 
+           outputs = generate_with_vllm(args.model2_name_or_path, args.revision2, prompt_token_ids_new, gen_args)
+
+       ### FOR DEBUGGING
+       #dataset = dataset.select(range(len(outputs)))
+
+       ######print(len(outputs), len(dataset["messages"]), len(outputs[0]["outputs"]))
+       ######print(outputs[-1]["outputs"][0])
+       output_ind = 0
+       #once = True
+       for i, messages in enumerate(dataset["messages"]):
+           if i not in finished_convs:
+               output = outputs[output_ind]
+               item = output["outputs"][0]
+               new_messages = copy.deepcopy(messages[:-1])
+               text = item["text"].replace("User: ", "", 1).replace("User A: ", "", 1)
+               #if once:
+               #    new_messages.append({"role": "user", "content": longlonglong*10})
+               #    once = False
+               #else:
+               new_messages.append({"role": "user", "content": text})
+               #dataset["messages"][msg_ind] = new_messages
+               #dataset["messages"][msg_ind].append({"role": "assistant", "content": item["text"]})
+               dataset = dataset.add_item({'messages': new_messages})
+               dataset = dataset.select(range(1,len(dataset)))
+               output_ind+=1
+           else:
+               if num_completions==1:
+                  table["messages"].append(messages[:-1])
+               #dataset = dataset.add_item({'messages': messages[:-1]})
+               dataset = dataset.select(range(1,len(dataset)))
+       '''for output, messages in zip(outputs, dataset["messages"]):
+           item = output["outputs"][0]
+           new_messages = copy.deepcopy(messages[:-1])
+           #print(len(new_messages), item)
+           text = item["text"].replace("User: ", "", 1).replace("User A: ", "", 1)
+           new_messages.append({"role": "user", "content": text})
+           #dataset["messages"][msg_ind] = new_messages
+           #dataset["messages"][msg_ind] = dataset["messages"][msg_ind][:-1]
+           #dataset["messages"][msg_ind].append({"role": "user", "content": item["text"][item["text"].find(':')+2:]})
+           dataset = dataset.add_item({'messages': new_messages})
+           dataset = dataset.select(range(1,len(dataset)))'''
+           
+       #####print(len(dataset["messages"]))
+       #print(dataset["messages"][0])
+       #####print('check 4')
+
+       # only do extra completions on last turn
+       if turn==args.num_turns-2:
+           gen_args.num_completions = num_completions
+           print('more completions!', gen_args.num_completions)
+       
+       # Assistant turn
+       finished_convs = set()
+       if "gpt-3.5" in args.model_name_or_path or "gpt-4" in args.model_name_or_path:
+           #try:
+           dataset_gpt = dataset.map(
+               lambda x: {"prompt": format_conversation(x["messages"])},#[:-1])},
+               num_proc=NUM_CPUS_FOR_DATASET_MAP,
+           )
+           messages = dataset_gpt["prompt"]
+           responses, finished_convs = asyncio.run(generate_with_openai(args.model_name_or_path, messages, args, gen_args))
+           outputs = [{"outputs": [{"text": r} for r in response]} for response in responses]
+           #outputs = [{"outputs": [{"text": response} for response in responses]}]
+           '''except openai.BadRequestError as e:
+                print(f"OpenAI BAD REQUEST error {e.status_code}: (e.response)")
+                outputs = [{"outputs": [{"text": ''}]} for i in dataset["messages"]]
+                break'''
+       elif "claude" in args.model_name_or_path:
+           dataset_claude = dataset.map(
+               lambda x: {"prompt": format_conversation(x["messages"])},
+               num_proc=NUM_CPUS_FOR_DATASET_MAP,
+           )
+           messages = dataset_claude["prompt"]
+           responses, finished_convs = asyncio.run(generate_with_claude(args.model_name_or_path, messages, args, gen_args))
+           outputs = [{"outputs": [{"text": r} for r in response]} for response in responses]
+       else:
+           tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, revision=args.revision)
+           dataset_processor = SFTDatasetProcessor(tokenizer=tokenizer, config=dataset_config)
+           dataset = dataset_processor.tokenize(dataset)
+           dataset = dataset_processor.filter(dataset)
+           prompt_token_ids = dataset[INPUT_IDS_PROMPT_KEY]
+                 
+           # filter out prompts which are beyond the model's max token length
+           prompt_token_ids_len = len(prompt_token_ids)
+           prompt_token_ids_new = []
+           for i, item in enumerate(prompt_token_ids):
+               if len(item) < max_model_len1:
+                   prompt_token_ids_new.append(item)
+               else:
+                   print('EXCEED!!!!!!!!!!!', len(item), max_model_len1)
+                   finished_convs.add(i)
+           if len(prompt_token_ids_new) != prompt_token_ids_len:
+              print(f"Filtered out {prompt_token_ids_len - len(prompt_token_ids_new)} prompts which exceeds max token length")
+           if len(prompt_token_ids_new)==0:
+               break
+           outputs = generate_with_vllm(args.model_name_or_path, args.revision, prompt_token_ids_new, gen_args)
+
+       #####print(len(outputs))
+       #input()
+       ### FOR DEBUGGING
+       #dataset = dataset.select(range(len(outputs)))
+       #####print(len(outputs), len(dataset["messages"]))
+       output_ind = 0
+       for i, messages in enumerate(dataset["messages"]):
+           #####print(output_ind, len(outputs[output_ind]['outputs']))
+           if len(set(tuple(item["text"]) for item in outputs[output_ind]["outputs"])) == 1 and gen_args.num_completions!=1:
+               num_prompt_with_identical_completions += 1
+               continue
+           
+           # eliminate any that did not have all num_completions succeed
+           if len(set(tuple(item["text"]) for item in outputs[output_ind]["outputs"])) != gen_args.num_completions:
+               continue    
+           
+           if i not in finished_convs:
+               for item in outputs[output_ind]["outputs"]:
+                   #output = outputs[output_ind]
+                   #item = output["outputs"][0]
+                   new_messages = copy.deepcopy(messages)
+                   text = item["text"].replace("User: ", "", 1).replace("User A: ", "", 1)
+                   new_messages.append({"role": "assistant", "content": text}) #item["text"]})
+                   #dataset["messages"][msg_ind] = new_messages
+                   #dataset["messages"][msg_ind].append({"role": "assistant", "content": item["text"]})
+                   dataset = dataset.add_item({'messages': new_messages})
+               dataset = dataset.select(range(1,len(dataset)))
+               output_ind+=1
+           else:
+               if num_completions==1:
+                  table["messages"].append(messages)
+               #dataset = dataset.add_item({'messages': messages})
+               dataset = dataset.select(range(1,len(dataset)))
+       
+       #####print(len(dataset["messages"]))
+       #print(dataset["messages"][0])
+       #####print('check 5')
+           
+
+    print(len(dataset["messages"]), "SHOULD NOT BE 0")
+    for messages in dataset["messages"]:
+         #new_messages = copy.deepcopy(messages[:-1])
+         #messages = messages[:-1]
+         #messages.append({"role": "assistant", "content": item["text"]})
+         table["messages"].append(messages)
+         #table["model_completion"].append(item["text"])
+         #table["reference_completion"].append(messages[-1]["content"])
+
+    print(len(table['messages']))
+    save_jsonl(args.save_filename, table)
+    print("Should be saved now")
+
+    ### ADD INFO HERE ###
+    if args.push_to_hub:
+        if args.hf_entity is None:
+            args.hf_entity = api.whoami()["name"]
+        full_repo_id = f"{args.hf_entity}/{args.hf_repo_id}"
+        timestamp = f"_{int(time.time())}"
+        if args.add_timestamp:
+            full_repo_id += timestamp
+        api.create_repo(full_repo_id, repo_type="dataset", exist_ok=True)
+        for f in [__file__, args.save_filename]:
+            api.upload_file(
+                path_or_fileobj=f,
+                path_in_repo=f.split("/")[-1],
+                repo_id=full_repo_id,
+                repo_type="dataset",
+            )
+        repo_full_url = f"https://huggingface.co/datasets/{full_repo_id}"
+        print(f"Pushed to {repo_full_url}")
+        run_command = " ".join(["python"] + sys.argv)
+        sft_card = RepoCard(
+            content=f"""\
+# allenai/open_instruct: Generation Dataset
+
+See https://github.com/allenai/open-instruct/blob/main/docs/algorithms/rejection_sampling.md for more detail
+
+## Configs
+
+```
+args:
+{pformat(vars(args))}
+
+dataset_config:
+{pformat(vars(dataset_config))}
+
+gen_args:
+{pformat(vars(gen_args))}
+```
+
+## Reproduce this dataset
+
+1. Download the `{[f.split("/")[-1] for f in [__file__, args.save_filename]]}` from the {repo_full_url}.
+2. Run `{run_command}`
+"""
+        )
+        sft_card.push_to_hub(
+            full_repo_id,
+            repo_type="dataset",
+        )
+
+
+        
+if __name__ == "__main__":
+    parser = ArgumentParserPlus((Args, DatasetConfig, GenerationArgs))
+    main(*parser.parse())