Applied edits

app.py

@@ -1,38 +1,51 @@
-# app.py
-
 import gradio as gr
-from run_llm import run_llm_interface
+import json
+from run_llm import template_all, prompt2_pos, prompt2_chunk, prompt2_parse, demon_pos, demon_chunk, demon_parse, model_mapping
+
+# Your existing code
 
-theme = gr.themes.Soft()
+# Function to process text based on model and task
+def process_text(model_name, task, text):
+    # Define prompts for each strategy based on the task
+    strategy_prompts = {
+        'Strategy 1': template_all.format(text),
+        'Strategy 2': {
+            'POS': prompt2_pos.format(text),
+            'Chunking': prompt2_chunk.format(text),
+            'Parsing': prompt2_parse.format(text),
+        }.get(task, "Invalid Task Selection for Strategy 2"),
+        'Strategy 3': {
+            'POS': demon_pos,
+            'Chunking': demon_chunk,
+            'Parsing': demon_parse,
+        }.get(task, "Invalid Task Selection for Strategy 3"),
+    }
 
-# 3 inputs:
-# - An input text which will be a random string
-# - First dropdown to select the task (POS, Chunking, Parsing)
-# - Second dropdown select the model type
-# use run_llm.py to feed the models and then output 3 results in 3 output boxes, one for each strategy (strategy 1, 2 and 3)
+    # Get the selected prompt based on the strategy
+    prompt = strategy_prompts.get(model_name, "Invalid Model Selection")
 
-# Define example instructions for testing
-#instruction_examples = [
-#    ["Describe the origin of the universe"],
-#    ["Explain the concept of artificial intelligence"],
-#    ["Describe the most common types of cancer"],
-#]
+    # Add your logic to feed the prompt to the selected model and get the result
+    result = "Processed Result"  # Replace this with your actual result
+    return result
 
-with gr.Interface(
-    fn=run_llm_interface,
+# Dropdown options for model and task
+model_options = list(model_mapping.keys())
+task_options = ['POS', 'Chunking', 'Parsing']
+
+# Gradio interface
+iface = gr.Interface(
+    fn=process_text,
     inputs=[
-        gr.Dropdown(['gpt3.5', 'vicuna-7b', 'vicuna-13b', 'fastchat-t5', 'llama-7b', 'llama-13b', 'llama-30b', 'alpaca'], label="Select Model", default='gpt3.5', key="model_path"),
-        gr.Dropdown(['POS Tagging', 'Chunking', 'Parsing'], label="Select Task", default='POS Tagging', key="prompt"),
-        gr.Textbox("", label="Enter Sentence", key="sentence", placeholder="Enter a sentence..."),
+        gr.Dropdown(model_options, label="Select Model"),
+        gr.Dropdown(task_options, label="Select Task"),
+        gr.Textbox(label="Input Text", placeholder="Enter the text to process..."),
     ],
     outputs=[
-        gr.Textbox("", label="Strategy 1 Output", key="output_1", readonly=True),
-        gr.Textbox("", label="Strategy 2 Output", key="output_2", readonly=True),
-        gr.Textbox("", label="Strategy 3 Output", key="output_3", readonly=True),
+        gr.Textbox(label="Strategy 1 QA Result", output_transform=lambda x: json.dumps(x, indent=2)),
+        gr.Textbox(label="Strategy 2 Instruction Result", output_transform=lambda x: json.dumps(x, indent=2)),
+        gr.Textbox(label="Strategy 3 Structured Prompting Result", output_transform=lambda x: json.dumps(x, indent=2)),
     ],
-    #examples=instruction_examples,
     live=False,
-    title="LLM Evaluator with Linguistic Scrutiny",
-    theme=theme
-) as iface:
-    iface.launch()
+)
+
+iface.launch()

run_llm.py

@@ -70,24 +70,6 @@ model_mapping = {
     # 'koala-13b': 'koala-13b',
 }
 
-for m in model_mapping.keys():
-    for eid, ent in enumerate(ents):
-        os.makedirs(f'result/prompt1_qa/{m}/ptb/per_ent/{ent}', exist_ok=True)
-        
-        os.makedirs(f'result/prompt2_instruction/pos_tagging/{m}/ptb', exist_ok=True)
-        os.makedirs(f'result/prompt2_instruction/chunking/{m}/ptb', exist_ok=True)
-        os.makedirs(f'result/prompt2_instruction/parsing/{m}/ptb', exist_ok=True)
-
-        os.makedirs(f'result/prompt3_structured_prompt/pos_tagging/{m}/ptb', exist_ok=True)
-        os.makedirs(f'result/prompt3_structured_prompt/chunking/{m}/ptb', exist_ok=True)
-        os.makedirs(f'result/prompt3_structured_prompt/parsing/{m}/ptb', exist_ok=True)
-
-
-#s = int(sys.argv[1])
-#e = int(sys.argv[2])
-
-#s = 0
-#e = 1000
 with open('sample_uniform_1k_2.txt', 'r') as f:
     selected_idx = f.readlines()
 selected_idx = [int(i.strip()) for i in selected_idx]#[s:e]
@@ -118,356 +100,3 @@ with open('demonstration_3_42_chunk.txt', 'r') as f:
 with open('demonstration_3_42_parse.txt', 'r') as f:
     demon_parse = f.read()
 
-
-def para(m):
-    c = 0
-    for n, p in m.named_parameters():
-        c += p.numel()
-    return c
-
-def main(args=None):
-
-    gid_list = selected_idx[args.start:args.end]
-
-
-    if 'gpt3' in args.model_path:
-        pass
-
-    else:
-        path = model_mapping[args.model_path]
-        model, tokenizer = load_model(
-            path,
-            args.device,
-            args.num_gpus,
-            args.max_gpu_memory,
-            args.load_8bit,
-            args.cpu_offloading,
-            revision=args.revision,
-            debug=args.debug,
-        )
-
-        whitelist_ids_pos = [tokenizer.encode(word)[1] for word in uni_tags]
-        bad_words_ids_pos = [[ids] for ids in range(tokenizer.vocab_size) if ids not in whitelist_ids_pos]
-
-        whitelist_ids_bio = [tokenizer.encode(word)[1] for word in bio_tags]
-        bad_words_ids_bio = [[ids] for ids in range(tokenizer.vocab_size) if ids not in whitelist_ids_bio]
-
-        whitelist_ids_chunk = [tokenizer.encode(word)[1] for word in chunk_tags]
-        bad_words_ids_chunk = [[ids] for ids in range(tokenizer.vocab_size) if ids not in whitelist_ids_chunk]
-
-        whitelist_ids_parse = [tokenizer.encode(word)[1] for word in syntags]
-        bad_words_ids_parse = [[ids] for ids in range(tokenizer.vocab_size) if ids not in whitelist_ids_parse]
-
-        if args.prompt == 1:
-            strategy1_qa(model, text, gid_list, tokenizer)
-        if args.prompt == 2:
-            strategy2_instruction(model, text, gid_list, tokenizer)
-        if args.prompt == 3:
-            strategy3_structured_prompt(model, text, gid_list, tokenizer, bad_words_ids_pos, bad_words_ids_bio, bad_words_ids_chunk, bad_words_ids_parse)
-
-
-def strategy1_qa(model, text, gid_list, tokenizer):
-        for gid in tqdm(gid_list, desc='Query'):
-            text = ptb[gid]['text']
-
-            for eid, ent in enumerate(ents):
-                os.makedirs(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/{ent}', exist_ok=True)
-                
-                if ent == 'NOUN' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/NOUN'):
-                    os.system(f'ln -sT ./NN result/prompt1_qa/{args.model_path}/ptb/per_ent/NOUN')
-                if ent == 'VERB' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/VERB'):
-                    os.system(f'ln -sT ./VB result/prompt1_qa/{args.model_path}/ptb/per_ent/VERB')
-                if ent == 'ADJ' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/ADJ'):
-                    os.system(f'ln -sT ./JJ result/prompt1_qa/{args.model_path}/ptb/per_ent/ADJ')
-                if ent == 'ADV' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/ADV'):
-                    os.system(f'ln -sT ./RB result/prompt1_qa/{args.model_path}/ptb/per_ent/ADV')
-                if ent == 'CONJ' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/CONJ'):
-                    os.system(f'ln -sT ./CC result/prompt1_qa/{args.model_path}/ptb/per_ent/CONJ')
-                if ent == 'DET' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/DET'):
-                    os.system(f'ln -sT ./DT result/prompt1_qa/{args.model_path}/ptb/per_ent/DET')
-                if ent == 'ADP' and not os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/ADP'):
-                    os.system(f'ln -sT ./DT result/prompt1_qa/{args.model_path}/ptb/per_ent/IN')
-
-                if os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/{ent}/{gid}.txt'):
-                    print(gid, ent, 'skip')
-                    continue
-                    
-
-                ## Get prompt
-                msg = template_single.format(ents_prompt[eid], text)
-
-                ## Run
-                if 'gpt3' in args.model_path:
-                    if os.path.exists(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/{ent}/{gid}.pkl'):
-                        print('Found cache')
-                        with open(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/{ent}/{gid}.pkl', 'rb') as f:
-                            outputs = pickle.load(f)
-                        outputs = outputs['choices'][0]['message']['content']
-                    else:
-                        outputs = gpt3(msg)
-                        if outputs is None:
-                            continue
-                        time.sleep(0.2)
-                    
-                else:
-                    conv = get_conversation_template(args.model_path)
-                    conv.append_message(conv.roles[0], msg)
-                    conv.append_message(conv.roles[1], None)
-                    conv.system = ''
-                    prompt = conv.get_prompt().strip()
-                    outputs = fastchat(prompt, model, tokenizer)
-
-                with open(f'result/prompt1_qa/{args.model_path}/ptb/per_ent/{ent}/{gid}.txt', 'w') as f:
-                    f.write(outputs)
-
-def strategy2_instruction(model, text, gid_list, tokenizer):
-        for gid in tqdm(gid_list, desc='Query'):
-            text = ptb[gid]['text']
-
-            ## POS tagging
-            if os.path.exists(f'result/prompt2_instruction/pos_tagging/{args.model_path}/ptb/{gid}.txt'):
-                print(gid, 'skip')
-
-            else:
-                msg = prompt2_pos.format(text)
-
-                if 'gpt3' in args.model_path:
-                    outputs = gpt3(msg)
-                    if outputs is None:
-                        continue
-                    time.sleep(0.2)
-
-                else:
-                    conv = get_conversation_template(args.model_path)
-                    conv.append_message(conv.roles[0], msg)
-                    conv.append_message(conv.roles[1], None)
-                    conv.system = ''
-                    prompt = conv.get_prompt()
-
-                    outputs = fastchat(prompt, model, tokenizer)
-
-                with open(f'result/prompt2_instruction/pos_tagging/{args.model_path}/ptb/{gid}.txt', 'w') as f:
-                    f.write(outputs)
-
-
-            ## Sentence chunking
-            if os.path.exists(f'result/prompt2_instruction/chunking/{args.model_path}/ptb/{gid}.txt'):
-                print(gid, 'skip')
-            if False:
-                pass
-            else:
-                msg = prompt2_chunk.format(text)
-
-                if 'gpt3' in args.model_path:
-                    outputs = gpt3(msg)
-                    if outputs is None:
-                        continue
-                    time.sleep(0.2)
-
-                else:
-                    conv = get_conversation_template(args.model_path)
-                    conv.append_message(conv.roles[0], msg)
-                    conv.append_message(conv.roles[1], None)
-                    conv.system = ''
-                    prompt = conv.get_prompt()
-
-                    outputs = fastchat(prompt, model, tokenizer)
-
-                print(args.model_path, gid, outputs)
-                with open(f'result/prompt2_instruction/chunking/{args.model_path}/ptb/{gid}.txt', 'w') as f:
-                    f.write(outputs)
-
-            
-            ## Parsing
-            if os.path.exists(f'result/prompt2_instruction/parsing/{args.model_path}/ptb/{gid}.txt'):
-                print(gid, 'skip')
-            
-            else:
-                msg = prompt2_parse.format(text)
-
-                if 'gpt3' in args.model_path:
-                    outputs = gpt3(msg)
-                    if outputs is None:
-                        continue
-                    time.sleep(0.2)
-
-                else:
-                    conv = get_conversation_template(args.model_path)
-                    conv.append_message(conv.roles[0], msg)
-                    conv.append_message(conv.roles[1], None)
-                    conv.system = ''
-                    prompt = conv.get_prompt()
-
-                    outputs = fastchat(prompt, model, tokenizer)
-
-                with open(f'result/prompt2_instruction/parsing/{args.model_path}/ptb/{gid}.txt', 'w') as f:
-                    f.write(outputs)
-
-
-def strategy3_structured_prompt(model, text, gid_list, tokenizer, bad_words_ids_pos, bad_words_ids_bio, bad_words_ids_chunk, bad_words_ids_parse):
-        for gid in tqdm(gid_list, desc='Query'):
-            text = ptb[gid]['text']
-            tokens = ptb[gid]['tokens']
-            poss = ptb[gid]['uni_poss']
-
-            ## POS tagging
-            if os.path.exists(f'result/prompt3_structured_prompt/pos_tagging/{args.model_path}/ptb/{gid}.txt'):
-                print(gid, 'skip')
-                continue
-
-            prompt = demon_pos + '\n' + 'C: ' + text + '\n' + 'T: '
-
-            if 'gpt3' in args.model_path:
-                outputs = gpt3(prompt)
-                if outputs is None:
-                    continue
-                time.sleep(0.2)
-
-            else:
-                pred_poss = []
-                for _tok, _pos in zip(tokens, poss):
-                    prompt = prompt + ' ' + _tok + '_'
-                    outputs = structured_prompt(prompt, model, tokenizer, bad_words_ids_pos)
-                    prompt = prompt + outputs
-                    pred_poss.append(outputs)
-
-            outputs = ' '.join(pred_poss)
-            with open(f'result/prompt3_structured_prompt/pos_tagging/{args.model_path}/ptb/{gid}.txt', 'w') as f:
-                f.write(outputs)
-
-
-            ## Chunking
-            if os.path.exists(f'result/prompt3_structured_prompt/chunking/{args.model_path}/ptb/{gid}.txt'):
-                print(gid, 'skip')
-                continue
-
-            prompt = demon_chunk + '\n' + 'C: ' + text + '\n' + 'T: '
-
-            if 'gpt3' in args.model_path:
-                outputs = gpt3(prompt)
-                print(outputs)
-                if outputs is None:
-                    continue
-                time.sleep(0.2)
-
-            else:
-                pred_chunk = []
-                for _tok, _pos in zip(tokens, poss):
-                    prompt = prompt + ' ' + _tok + '_'
-
-                    # Generate BIO
-                    outputs_bio = structured_prompt(prompt, model, tokenizer, bad_words_ids_bio)
-                    prompt = prompt + outputs_bio + '-'
-
-                    # Generate tag
-                    outputs_chunk = structured_prompt(prompt, model, tokenizer, bad_words_ids_chunk)
-                    prompt = prompt + outputs_chunk
-
-                    pred_chunk.append((outputs_bio + '-' + outputs_chunk))
-
-                outputs = ' '.join(pred_chunk)
-
-            with open(f'result/prompt3_structured_prompt/chunking/{args.model_path}/ptb/{gid}.txt', 'w') as f:
-                f.write(outputs)
-
-            ## Parsing
-            if os.path.exists(f'result/prompt3_structured_prompt/parsing/{args.model_path}/ptb/{gid}.txt'):
-                print(gid, 'skip')
-                continue
-
-            prompt = demon_parse + '\n' + 'C: ' + text + '\n' + 'T: '
-
-            if 'gpt3' in args.model_path:
-                outputs = gpt3(prompt)
-                if outputs is None:
-                    continue
-                time.sleep(0.2)
-
-            else:
-                pred_syn = []
-                for _tok, _pos in zip(tokens, poss):
-                    prompt = prompt + _tok + '_'
-                    outputs = structured_prompt(prompt, model, tokenizer, bad_words_ids_parse)
-                    pred_syn.append(outputs)
-
-            with open(f'result/prompt3_structured_prompt/parsing/{args.model_path}/ptb/{gid}.txt', 'w') as f:
-                f.write(' '.join(pred_syn))
-
-
-def structured_prompt(prompt, model, tokenizer, bad_words_ids):
-    input_ids = tokenizer([prompt]).input_ids
-    output_ids = model.generate(
-        torch.as_tensor(input_ids).cuda(),
-        max_new_tokens=1,
-        bad_words_ids=bad_words_ids,
-    )
-
-    if model.config.is_encoder_decoder:
-        output_ids = output_ids[0]
-    else:
-        output_ids = output_ids[0][len(input_ids[0]) :]
-    outputs = tokenizer.decode(
-        output_ids, skip_special_tokens=True, spaces_between_special_tokens=False
-    )
-
-    return outputs
-
-
-def fastchat(prompt, model, tokenizer):
-    input_ids = tokenizer([prompt]).input_ids
-    output_ids = model.generate(
-        torch.as_tensor(input_ids).cuda(),
-        do_sample=True,
-        temperature=args.temperature,
-        repetition_penalty=args.repetition_penalty,
-        max_new_tokens=args.max_new_tokens,
-    )
-
-    if model.config.is_encoder_decoder:
-        output_ids = output_ids[0]
-    else:
-        output_ids = output_ids[0][len(input_ids[0]) :]
-    outputs = tokenizer.decode(
-        output_ids, skip_special_tokens=True, spaces_between_special_tokens=False
-    )
-
-    #print('Empty system message')
-    #print(f"{conv.roles[0]}: {msg}")
-    #print(f"{conv.roles[1]}: {outputs}")
-
-    return outputs
-
-
-def gpt3(prompt):
-    try:
-        response = openai.ChatCompletion.create(
-            model=model_mapping[args.model_path], messages=[{"role": "user", "content": prompt}])
-
-        return response['choices'][0]['message']['content']
-
-    except Exception as err:
-        print('Error')
-        print(err)
-
-        return None
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    add_model_args(parser)
-    parser.add_argument("--temperature", type=float, default=0.7)
-    parser.add_argument("--repetition_penalty", type=float, default=1.0)
-    parser.add_argument("--max-new-tokens", type=int, default=512)
-    parser.add_argument("--debug", action="store_true")
-    parser.add_argument("--message", type=str, default="Hello! Who are you?")
-    parser.add_argument("--start", type=int, default=0)
-    parser.add_argument("--end", type=int, default=1000)
-    parser.add_argument("--prompt", required=True, type=int, default=None)
-    # parser.add_argument("--system_msg", required=True, type=str, default='default_system_msg')
-    args = parser.parse_args()
-
-    # Reset default repetition penalty for T5 models.
-    if "t5" in args.model_path and args.repetition_penalty == 1.0:
-        args.repetition_penalty = 1.2
-
-    main(args)