create llama2-7B lora finetune shell command; complete part of the Chatlogic framework

Author: Wzs010429

Diff for: Baseline Experiment/Llama_2_7B_Finetune/Alpaca_data_processing.py

@@ -25,9 +25,18 @@ def main():
     # load data
     dataset = load_dataset("qbao775/PARARULE-Plus")
 
+    # Define limits for each split
+    limits = {
+        "train": 10000,
+        "validation": 3000,
+        "test": 3000
+    }
+
     # Convert each data slice and save it separately
     for split, filename in zip(["train", "validation", "test"], ["train.json", "val.json", "test.json"]):
-        transformed_data = transform_data(list(dataset[split]))
+        # Slice the dataset
+        data_slice = dataset[split]
+        transformed_data = transform_data(list(data_slice))
         save_to_json(transformed_data, filename)
         print(f"Transformed and saved {split} data to {filename}.")
 

Diff for: Baseline Experiment/Llama_2_7B_Finetune/Fine-tune Llama2-7B.sh

@@ -0,0 +1,18 @@
+ssh https://github.com/tloen/alpaca-lora.git
+# put the data "./Alpaca_PARARULE-Plus.json" into the directory same as the github repo
+python finetune.py \
+    --base_model 'meta-llama/Llama-2-7b-hf' \
+    --data_path './Alpaca_PARARULE-Plus.json' \
+    --output_dir './lora-alpaca' \
+    --batch_size 128 \
+    --micro_batch_size 4 \
+    --num_epochs 10 \
+    --learning_rate 1e-4 \
+    --cutoff_len 512 \
+    --val_set_size 2000 \
+    --lora_r 8 \
+    --lora_alpha 16 \
+    --lora_dropout 0.05 \
+    --lora_target_modules '[q_proj,v_proj]' \
+    --train_on_inputs \
+    --group_by_length

Diff for: Baseline Experiment/Llama_2_7B_Finetune/get_data_PARARULE-Plus.py

@@ -6,7 +6,7 @@
     data = json.load(f)
 
 # Randomly sample 5000 entries
-sampled_data = random.sample(data, 5000)
+sampled_data = random.sample(data, 10000)
 
 # Save the sampled data
 with open('Alpaca_PARARULE-Plus.json', 'w', encoding='utf-8') as f:

Diff for: call_openai_API.py

@@ -1,4 +1,8 @@
 import openai
+import os
+
+openai.api_key = api_key = os.getenv("OPENAI_API_KEY")
+
 
 def ai_function_generation(demo, context, question, requirements, model = "gpt-3.5-turbo"):
     # parse args to comma separated string
@@ -18,7 +22,7 @@ def ai_function_generation(demo, context, question, requirements, model = "gpt-3
 def ai_generation_adjustment(demo, code, error_message, model = "gpt-3.5-turbo"):
     # parse args to comma separated string
     messages = [{"role": "user",
-                 "content": f"{demo}\n Here is the original code: ```{code}```\n And the exception that was thrown is: ```{error_message}```"}]
+            "content": f"{demo}\n Here is the original code: ```{code}```\n And the exception that was thrown is: ```{error_message}```"}]
 
     response = openai.ChatCompletion.create(
         model=model,
@@ -31,7 +35,7 @@ def ai_generation_adjustment(demo, code, error_message, model = "gpt-3.5-turbo")
 def ai_generation_check(demo, question, model = "gpt-3.5-turbo"):
     # parse args to comma separated string
     messages = [{"role": "user",
-                 "content": f"{demo}\n The sentence you are expected to decide is: ```{question}```"}]
+            "content": f"{demo}\n The sentence you are expected to decide is: ```{question}```"}]
 
     response = openai.ChatCompletion.create(
         model=model,

Diff for: complete_reasoning.py renamed to complete_reasoning_3.5.py

@@ -2,12 +2,12 @@
 import call_openai_API
 import templates
 import openai
-import openai_API_keys
 import subprocess
 import csv
+import os
 
 # Initialize the OpenAI API client
-openai.api_key = openai_API_keys.OPENAI_API_KEY
+openai.api_key = api_key = os.getenv("OPENAI_API_KEY")
 #Define the file name
 JSON_filename = 'PARARULE_plus_step2_People_sample.json'
 PY_filename = 'pyDatalog_processing.py'
@@ -36,19 +36,19 @@ def check_pos_neg(string):
     return None
 
 def Judgement(demo, question, model):
-    result_string = call_openai_API.ai_generation_check(demo, question, model)
+    result_string = call_openai_API.ai_generation_check(demo, question, model = "gpt-3.5-turbo")
     return result_string
 
 
 # Complete Communication with ChatGPT
-def Generation(demo, context, question, requirements, model):
+def Generation(demo, context, question, requirements, model = "gpt-3.5-turbo"):
 
     result_string = call_openai_API.ai_function_generation(demo, context, question, requirements, model)
     return result_string
 
 # Communication(templates.templates["agent_engineer"], PARARULE_Plus.PARARULE_Plus_dataset['train'][200]['context'], PARARULE_Plus.PARARULE_Plus_dataset['train'][200]['question'], templates.templates["no_extra_content"], "gpt-3.5-turbo")
 
-def Adjustment(demo, code, error_message, model):
+def Adjustment(demo, code, error_message, model = "gpt-3.5-turbo"):
 
     result_string = call_openai_API.ai_generation_adjustment(demo, code, error_message, model)
     return result_string
@@ -79,12 +79,12 @@ def write_record(filename, id, value, code, step, flag):
 with open(JSON_filename, 'r') as file:
     data = json.load(file)
 
-correct_num = 0
+correct_num = 10
 for i in range(0, 1):
     try:
         result_string = extract_string(Generation(templates.templates["agent_engineer"], data[i]['context'],
                         data[i]['question'],
-                        templates.templates["no_extra_content"], "gpt-3.5-turbo"))
+                        templates.templates["no_extra_content"]))
         print(result_string)
         with open(PY_filename, 'w') as file:
             file.write("{}".format(result_string))
@@ -93,7 +93,7 @@ def write_record(filename, id, value, code, step, flag):
         flag = 0
         while(output.strip() != '1' and output.strip() != '0'):
             result_string = extract_string(Adjustment(templates.templates["adjustment_agent"],
-                                                            result_string, output, "gpt-3.5-turbo"))
+                                                            result_string, output))
             with open(PY_filename, 'w') as file:
                 file.write("{}".format(result_string))
             print("reprocessing...")

Diff for: openai_API_keys.py

@@ -2,33 +2,39 @@
 from pyDatalog import pyDatalog
 try:
     # Declare the pyDatalog variables
-    pyDatalog.create_terms('X, strong, big, thin, short, smart, rough, bad, huge, poor, quiet, wealthy, dull, nice, sad, kind')
+    pyDatalog.create_terms('X, strong, huge, big, short, little, quiet, wealthy, smart, dull, rough, sad, thin, bad, kind, nice, poor, small')
 
     # Define the facts
     +strong('Dave')
+    +huge('Dave')
     +big('Dave')
-    +thin('Charlie')
-    +short('Charlie')
-    +smart('Anne')
-    +rough('Alan')
-    +bad('Alan')
+    +short('Gary')
+    +little('Gary')
+    +quiet('Bob')
+    +wealthy('Bob')
+    +smart('Bob')
+    +dull('Harry')
+    +rough('Harry')
+    +sad('Harry')
 
     # Define the rules
-    rough(X) <= ~huge(X)
-    quiet(X) <= ~poor(X)
-    wealthy(X) <= smart(X)
-    nice(X) <= wealthy(X) & ~dull(X)
-    sad(X) <= rough(X) & ~huge(X)
-    dull(X) <= thin(X) & short(X)
-    bad(X) <= dull(X) & ~wealthy(X)
-    kind(X) <= quiet(X)
+    quiet(X) <= strong(X)
+    thin(X) <= short(X) & little(X)
+    bad(X) <= dull(X) & rough(X)
+    kind(X) <= quiet(X) & wealthy(X)
+    
+    # Define the constraints
+    small(X) <= thin(X)
+    wealthy(X) <= quiet(X)
+    nice(X) <= kind(X)
+    poor(X) <= bad(X)
 
     # Query the knowledge base
-    result = ~kind('Alan')
+    result = ~small('Gary')
     if result:
         print(1)
     else:
         print(0)
 except Exception as e:
     traceback_info = traceback.format_exc()
-    print(traceback_info)
+    print(traceback_info)

Diff for: pyDatalog_processing.py

@@ -16,7 +16,7 @@
     with open(input_file, "r") as json_file:
         json_data_list = json.load(json_file)
 
-    random_sample = random.sample(json_data_list, 20)
+    random_sample = random.sample(json_data_list, 40)
 
     with open(output_file, "w") as output_file:
         json.dump(random_sample, output_file)