github/AutoGPT
1
1
Fork 0
mirror of https://github.com/Significant-Gravitas/AutoGPT.git synced 2026-01-08 22:58:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

working regex (#352)

Browse Source
This commit is contained in:
Silen Naihin
2023-09-04 18:19:35 -07:00
committed by GitHub
parent 57907bcda1
commit 2dc1a0a9cd
13 changed files with 1644 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
paper/TestRevenueRetrieval/auto-gpt-turbo/selected_logs.json → paper/TestThreeSum/auto-gpt-turbo/flagged_actions.json
View File

98
paper/TestThreeSum/auto-gpt/flagged_actions.json Normal file
View File

@@ -0,0 +1,98 @@
{
"2023-08-06 08:12:00+00:00": {
"1": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I need to create a three_sum function in a file called code.py.\",\n \"reasoning\": \"Since I haven't started working on the task yet, I should begin by writing the three_sum function in Python and save it to a file called code.py.\",\n \"plan\": \"- Write the three_sum function in Python\\n- Save the function to a file called code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create the three_sum function and save it to a file called code.py.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\\n# Example usage:\\n# nums = [2, 7, 11, 15]\\n# target = 20\\n# print(three_sum(nums, target))\"\n }\n }\n}"
},
"2": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created the three_sum function and saved it to a file called code.py.\",\n \"reasoning\": \"Now that the function is saved in a file, I should execute the file to ensure the function works correctly.\",\n \"plan\": \"- Execute the code.py file\\n- Verify the function works correctly\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the code.py file to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"code.py\"\n }\n }\n}"
},
"3": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have executed the code.py file, but I didn't get any output.\",\n \"reasoning\": \"The three_sum function is not being called in the code.py file. I should call the function with the example input and print the result to verify its correctness.\",\n \"plan\": \"- Modify the code.py file to call the three_sum function with the example input and print the result\\n- Execute the modified code.py file\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now modify the code.py file to call the three_sum function with the example input and print the result, then execute the modified file.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\\n# Example usage:\\nnums = [2, 7, 11, 15]\\ntarget = 20\\nprint(three_sum(nums, target))\"\n }\n }\n}"
},
"4": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have modified the code.py file to call the three_sum function with the example input and print the result.\",\n \"reasoning\": \"Now that the code.py file has been modified, I should execute it again to verify the correctness of the three_sum function.\",\n \"plan\": \"- Execute the modified code.py file\\n- Verify the function works correctly\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the modified code.py file to verify the correctness of the three_sum function.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"code.py\"\n }\n }\n}"
}
},
"2023-08-13 01:53:00+00:00": {
"1": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I need to create a three_sum function in a file called code.py.\",\n \"reasoning\": \"Since I haven't started working on the task yet, I should begin by writing the function and saving it to a file.\",\n \"plan\": \"- Write the three_sum function\\n- Save the function to code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create the three_sum function and save it to a file called code.py.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\"\n }\n }\n}"
},
"2": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created the three_sum function and saved it to code.py. Now, I need to execute the code to ensure it works correctly.\",\n \"reasoning\": \"Executing the code will help me verify if the function works as expected and fulfills the given goals.\",\n \"plan\": \"- Execute the code in code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the code in code.py to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"code.py\"\n }\n }\n}"
},
"3": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have executed the code in code.py, but I need to test the three_sum function to ensure it works correctly.\",\n \"reasoning\": \"Testing the function with a sample input will help me verify if it produces the correct output and fulfills the given goals.\",\n \"plan\": \"- Create a test script to call the three_sum function with a sample input\\n- Execute the test script\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create a test script to call the three_sum function with a sample input and execute it to ensure the function works correctly.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"test_code.py\",\n \"text\": \"from code import three_sum\\n\\nnums = [2, 7, 11, 15]\\ntarget = 20\\nresult = three_sum(nums, target)\\nprint(result)\"\n }\n }\n}"
},
"4": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created a test script to call the three_sum function with a sample input. Now, I need to execute the test script to ensure the function works correctly.\",\n \"reasoning\": \"Executing the test script will help me verify if the three_sum function produces the correct output and fulfills the given goals.\",\n \"plan\": \"- Execute the test script in test_code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the test script in test_code.py to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"test_code.py\"\n }\n }\n}"
}
},
"2023-08-13 02:18:00+00:00": {
"1": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I need to create a three_sum function in a file called code.py.\",\n \"reasoning\": \"Since I haven't started working on the task yet, I should begin by writing the three_sum function in Python and save it to a file called code.py.\",\n \"plan\": \"- Write the three_sum function in Python\\n- Save the function to a file called code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create the three_sum function and save it to a file called code.py.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\\n# Example usage:\\n# nums = [2, 7, 11, 15]\\n# target = 20\\n# print(three_sum(nums, target))\"\n }\n }\n}"
},
"2": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created the three_sum function and saved it to a file called code.py.\",\n \"reasoning\": \"Now that the function is saved in a file, I should execute the file to ensure the function works correctly.\",\n \"plan\": \"- Execute the code.py file\\n- Verify the function works correctly\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the code.py file to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"code.py\"\n }\n }\n}"
},
"3": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have executed the code.py file, but I didn't see any output.\",\n \"reasoning\": \"Since the example usage in the code.py file is commented out, I should uncomment it and execute the file again to see the output.\",\n \"plan\": \"- Uncomment the example usage in the code.py file\\n- Execute the code.py file again\\n- Verify the function works correctly\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now uncomment the example usage in the code.py file and execute it again to see the output.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\\n# Example usage:\\nnums = [2, 7, 11, 15]\\ntarget = 20\\nprint(three_sum(nums, target))\"\n }\n }\n}"
}
},
"2023-08-13 08:13:00+00:00": {
"1": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I need to create a three_sum function in a file called code.py.\",\n \"reasoning\": \"Since I haven't started working on the task yet, I should begin by writing the three_sum function in Python and save it to a file called code.py.\",\n \"plan\": \"- Write the three_sum function in Python\\n- Save the function to a file called code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create the three_sum function and save it to a file called code.py.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\"\n }\n }\n}"
},
"2": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created the three_sum function and saved it to a file called code.py. Now, I need to execute the code to ensure it works correctly.\",\n \"reasoning\": \"Since I have written the three_sum function, the next step is to execute the code to make sure it works as expected.\",\n \"plan\": \"- Execute the code.py file\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the code.py file to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"code.py\"\n }\n }\n}"
},
"3": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have executed the code.py file, but I didn't test the three_sum function.\",\n \"reasoning\": \"I need to test the three_sum function to ensure it works correctly.\",\n \"plan\": \"- Create a test script to test the three_sum function\\n- Execute the test script\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create a test script to test the three_sum function and execute it.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"test_code.py\",\n \"text\": \"from code import three_sum\\n\\nnums = [2, 7, 11, 15]\\ntarget = 20\\nresult = three_sum(nums, target)\\nprint(result)\"\n }\n }\n}"
},
"4": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created a test script to test the three_sum function. Now, I need to execute the test script to ensure the function works correctly.\",\n \"reasoning\": \"Since I have written the test script, the next step is to execute it to make sure the three_sum function works as expected.\",\n \"plan\": \"- Execute the test_code.py file\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the test_code.py file to test the three_sum function.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"test_code.py\"\n }\n }\n}"
}
},
"2023-08-19 08:12:39+00:00": {
"1": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I need to create a three_sum function in a file called code.py.\",\n \"reasoning\": \"Since I haven't started working on the task yet, the first step is to write the function and save it to a file.\",\n \"plan\": \"- Write the three_sum function\\n- Save the function to code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create the three_sum function and save it to a file called code.py.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\\n# Example usage:\\n# nums = [2, 7, 11, 15]\\n# target = 20\\n# print(three_sum(nums, target))\"\n }\n }\n}"
},
"2": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created the three_sum function and saved it to code.py. Now, I need to execute the code to ensure it works correctly.\",\n \"reasoning\": \"Executing the code will help me verify if the function works as expected and fulfills the given goals.\",\n \"plan\": \"- Execute the code in code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the code in code.py to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"code.py\"\n }\n }\n}"
},
"3": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have executed the code in code.py, but I didn't get any output because the example usage is commented out.\",\n \"reasoning\": \"To verify if the function works correctly, I need to uncomment the example usage and execute the code again.\",\n \"plan\": \"- Uncomment the example usage\\n- Execute the code in code.py\",\n \"criticism\": \"I should have uncommented the example usage before executing the code.\",\n \"speak\": \"I will now uncomment the example usage in code.py and execute the code again to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\\n# Example usage:\\nnums = [2, 7, 11, 15]\\ntarget = 20\\nprint(three_sum(nums, target))\"\n }\n }\n}"
}
},
"2023-08-20 08:12:35+00:00": {
"1": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I need to create a three_sum function in a file called sample_code.py.\",\n \"reasoning\": \"Since I haven't started working on the task yet, I should begin by writing the three_sum function and saving it to a file.\",\n \"plan\": \"- Write the three_sum function\\n- Save the function to sample_code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now create the three_sum function and save it to a file called sample_code.py.\"\n },\n \"command\": {\n \"name\": \"write_to_file\",\n \"args\": {\n \"filename\": \"sample_code.py\",\n \"text\": \"def three_sum(nums, target):\\n nums_dict = {}\\n for i, num in enumerate(nums):\\n nums_dict[num] = i\\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n complement = target - nums[i] - nums[j]\\n if complement in nums_dict and nums_dict[complement] != i and nums_dict[complement] != j:\\n return [i, j, nums_dict[complement]]\\n\"\n }\n }\n}"
},
"2": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I have created the three_sum function and saved it to sample_code.py.\",\n \"reasoning\": \"Now that the function is saved, I should execute the Python file to ensure the function works correctly.\",\n \"plan\": \"- Execute sample_code.py\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now execute the sample_code.py file to ensure the three_sum function works correctly.\"\n },\n \"command\": {\n \"name\": \"execute_python_file\",\n \"args\": {\n \"filename\": \"sample_code.py\"\n }\n }\n}"
},
"4": {
"role": "assistant",
"content": "{\n \"thoughts\": {\n \"text\": \"I encountered an error while trying to import the three_sum function from sample_code.py.\",\n \"reasoning\": \"The error might be due to the current working directory. I should check the list of files in the current directory to ensure sample_code.py is present.\",\n \"plan\": \"- List files in the current directory\",\n \"criticism\": \"N/A\",\n \"speak\": \"I will now list the files in the current directory to ensure sample_code.py is present.\"\n },\n \"command\": {\n \"name\": \"list_files\",\n \"args\": {\n \"directory\": \".\"\n }\n }\n}"
}
}
}

3
paper/TestThreeSum/babyagi/flagged_actions.json Normal file
View File

@@ -0,0 +1,3 @@
{
"2023-08-14 08:16:00+00:00": {}
}

376
paper/TestThreeSum/beebot/flagged_actions.json Normal file
View File

@@ -0,0 +1,376 @@
{
"2023-08-04 08:13:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"output.txt\",\n \"text_content\": \"Analysis of how companies are addressing challenges or trends\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
},
"7": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"test.py\",\n \"text_content\": \"# mypy: ignore-errors\\nfrom code import multiply_int\\n\\n\\ndef test_multiply_int(num: int, multiplier, expected_result: int) -> None:\\n result = multiply_int(num, multiplier)\\n print(result)\\n assert (\\n result == expected_result\\n ), f\\\"AssertionError: Expected the output to be {expected_result}\\\"\\n\\n\\nif __name__ == \\\"__main__\\\":\\n # test the trivial case\\n num = 4\\n multiplier = 2\\n expected_result = 8\\n test_multiply_int(num, multiplier, expected_result)\\n\\n # so its not hard coded\\n num = 7\\n multiplier = 7\\n expected_result = 49\\n test_multiply_int(num, multiplier, expected_result)\\n\\n # negative numbers\\n num = -6\\n multiplier = 2\\n expected_result = -12\\n test_multiply_int(num, multiplier, expected_result)\\n\\n # additional test case\\n num = 10\\n multiplier = 5\\n expected_result = 50\\n test_multiply_int(num, multiplier, expected_result)\\n\"\n}"
}
},
"11": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\",\n \"text_content\": \"def three_sum(nums):\\n target = 0\\n n = len(nums)\\n for i in range(n - 2):\\n for j in range(i + 1, n - 1):\\n for k in range(j + 1, n):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\\n return []\"\n}"
}
},
"14": {
"role": "assistant",
"content": null,
"function_call": {
"name": "read_file",
"arguments": "{\n \"filename\": \"companies.txt\"\n}"
}
},
"15": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"test.py\",\n \"text_content\": \"# mypy: ignore-errors\\nfrom code import three_sum\\n\\n\\ndef test_three_sum(nums, target, expected_result):\\n result = three_sum(nums)\\n assert result == expected_result, f\\\"AssertionError: Expected the output to be {expected_result}\\\"\\n\\n\\nif __name__ == \\\"__main__\\\":\\n # test case 1\\n nums = [1, 2, 3, 4, 5]\\n target = 6\\n expected_result = [0, 1, 3]\\n test_three_sum(nums, target, expected_result)\\n\\n # test case 2\\n nums = [10, 20, 30, 40, 50]\\n target = 70\\n expected_result = [1, 2, 4]\\n test_three_sum(nums, target, expected_result)\\n\\n # test case 3\\n nums = [5, 10, 15, 20, 25]\\n target = 50\\n expected_result = [0, 2, 4]\\n test_three_sum(nums, target, expected_result)\\n\"\n}"
}
},
"17": {
"role": "assistant",
"content": null,
"function_call": {
"name": "read_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
},
"19": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"test.py\"\n}"
}
}
},
"2023-08-13 01:10:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums, target):\\n num_dict = {}\\n for i, num in enumerate(nums):\\n complement = target - num\\n if complement in num_dict:\\n return [num_dict[complement], i]\\n num_dict[num] = i\\n return []\"\n}"
}
}
},
"2023-08-13 01:53:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
}
},
"2023-08-13 02:17:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums):\\n n = len(nums)\\n for i in range(n-2):\\n for j in range(i+1, n-1):\\n for k in range(j+1, n):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\\n return []\"\n}"
}
}
},
"2023-08-13 02:38:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums, target):\\n num_dict = {}\\n for i, num in enumerate(nums):\\n complement = target - num\\n if complement in num_dict:\\n return [num_dict[complement], i]\\n num_dict[num] = i\\n return []\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"code.py\"\n}"
}
}
},
"2023-08-13 08:12:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\"\n}"
}
}
},
"2023-08-13 17:31:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"code.py\"\n}"
}
}
},
"2023-08-14 08:13:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums, target):\\n num_dict = {}\\n for i, num in enumerate(nums):\\n complement = target - num\\n if complement in num_dict:\\n return [num_dict[complement], i]\\n num_dict[num] = i\\n return []\"\n}"
}
}
},
"2023-08-14 21:37:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums, target):\\n num_dict = {}\\n for i, num in enumerate(nums):\\n complement = target - num\\n if complement in num_dict:\\n return [num_dict[complement], i]\\n num_dict[num] = i\\n return []\"\n}"
}
}
},
"2023-08-16 08:14:00+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\"\n}"
}
}
},
"2023-08-19 08:11:51+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"code.py\",\n \"code\": \"def three_sum(nums, target):\\n num_dict = {}\\n for i, num in enumerate(nums):\\n complement = target - num\\n if complement in num_dict:\\n return [num_dict[complement], i]\\n num_dict[num] = i\\n return []\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"code.py\"\n}"
}
},
"8": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"code.py\"\n}"
}
}
},
"2023-08-20 08:13:03+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"sample_code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"sample_code.py\"\n}"
}
},
"8": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"test_code.py\",\n \"code\": \"from sample_code import three_sum\\n\\nnums = [2, 7, 11, 15]\\ntarget = 20\\n\\nresult = three_sum(nums, target)\\nprint(result)\"\n}"
}
}
},
"2023-08-22 08:13:27+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"sample_code.py\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"sample_code.py\",\n \"text_content\": \"def three_sum(nums, target):\\n for i in range(len(nums)-2):\\n for j in range(i+1, len(nums)-1):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\\n return []\"\n}"
}
},
"8": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"sample_code.py\"\n}"
}
}
},
"2023-08-24 03:24:31+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"sample_code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\\n return []\"\n}"
}
}
},
"2023-08-24 08:13:31+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"sample_code.py\"\n}"
}
}
},
"2023-08-29 08:14:05+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"sample_code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\\n return []\"\n}"
}
}
},
"2023-08-30 08:14:10+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"sample_code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"sample_code.py\"\n}"
}
}
},
"2023-08-31 15:33:56+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"sample_code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)):\\n for j in range(i+1, len(nums)):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"sample_code.py\"\n}"
}
},
"8": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"sample_code.py\"\n}"
}
},
"10": {
"role": "assistant",
"content": null,
"function_call": {
"name": "execute_python_file",
"arguments": "{\n \"file_path\": \"sample_code.py\"\n}"
}
}
},
"2023-09-01 08:14:47+00:00": {
"4": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"sample_code.py\"\n}"
}
},
"6": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_file",
"arguments": "{\n \"filename\": \"sample_code.py\"\n}"
}
},
"8": {
"role": "assistant",
"content": null,
"function_call": {
"name": "write_python_code",
"arguments": "{\n \"file_name\": \"sample_code.py\",\n \"code\": \"def three_sum(nums, target):\\n for i in range(len(nums)-2):\\n for j in range(i+1, len(nums)-1):\\n for k in range(j+1, len(nums)):\\n if nums[i] + nums[j] + nums[k] == target:\\n return [i, j, k]\\n return []\"\n}"
}
}
}
}

886
paper/TestThreeSum/beebot/selected_logs_request.json Normal file
View File

File diff suppressed because one or more lines are too long

0
paper/TestRevenueRetrieval/auto-gpt-turbo/selected_logs_nested.json → paper/TestThreeSum/evo/flagged_actions.json
View File

3
paper/TestThreeSum/gpt-engineer/flagged_actions.json Normal file
View File

@@ -0,0 +1,3 @@
{
"2023-09-01 08:13:53+00:00": {}
}

8
paper/TestThreeSum/mini-agi/flagged_actions.json Normal file
View File

@@ -0,0 +1,8 @@
{
"2023-08-14 08:13:00+00:00": {},
"2023-08-14 17:10:00+00:00": {},
"2023-08-20 08:13:26+00:00": {},
"2023-08-24 03:24:34+00:00": {},
"2023-08-31 15:33:52+00:00": {},
"2023-09-01 08:13:39+00:00": {}
}

7
paper/TestThreeSum/polygpt/flagged_actions.json Normal file
View File

@@ -0,0 +1,7 @@
{
"2023-08-14 08:13:00+00:00": {},
"2023-08-14 08:37:00+00:00": {},
"2023-08-14 09:48:00+00:00": {},
"2023-08-31 15:34:10+00:00": {},
"2023-09-01 08:13:31+00:00": {}
}

8
paper/TestThreeSum/smol-developer/flagged_actions.json Normal file
View File

@@ -0,0 +1,8 @@
{
"2023-08-31 15:25:08+00:00": {},
"2023-08-31 15:33:23+00:00": {},
"2023-09-01 08:13:11+00:00": {},
"2023-09-01 15:37:02+00:00": {},
"2023-09-01 16:08:58+00:00": {},
"2023-09-01 17:17:30+00:00": {}
}

6
paper/TestThreeSum/turbo/flagged_actions.json Normal file
View File

@@ -0,0 +1,6 @@
{
"2023-08-30 23:11:52+00:00": {},
"2023-08-31 15:35:06+00:00": {},
"2023-09-01 08:13:41+00:00": {},
"2023-09-01 17:05:12+00:00": {}
}

200
paper/agent_action_regex.py
View File

@@ -1,44 +1,220 @@
import re
import json
def is_action_auto_gpt(log):
"""AutoGPTs actions are defined by the presence of the "command" key."""
return bool(re.search(r'"command"\s*:', log))
"""AutoGPTs actions are defined by the presence of the "command" key.
World state actions
- web_search
- write_to_file
- browse_website
- execute_python_file
- list_files
Internal actions
- goals_accomplished
"""Other notes
Performing actions
- web_search
- write_to_file
- browse_website
Internal actions
- goals_accomplished
"""
Input
The "content" key of an LLM response
"""
# Check for the existence of the "command" key in the log
command_existence = bool(re.search(r'"command"\s*:', log))
if command_existence:
# Convert the JSON-like string to a Python dictionary
log_dict = json.loads(log)
# Check if the "command" key exists and has a "name" key
if "command" in log_dict and "name" in log_dict["command"]:
command_name = log_dict["command"]["name"]
# List of command names that signify an action
action_command_names = [
"web_search",
"write_to_file",
"browse_website",
"execute_python_file",
"list_files",
]
# Check if the command name matches any in the list
return command_name in action_command_names
return False
def is_openai_function(log):
"""OpenAI API function calls are determined by the presence of the "function_call" key."""
return bool(re.search(r'"function_call"\s*:', log))
"""OpenAI API function calls are determined by the presence of the "function_call" key.
Beebot
World state actions
- get_html_content
- read_file
- write_file
- wolfram_alpha_query
- write_python_code
- execute_python_file
- google_search
- wikipedia
Internal actions
- get_more_tools
- exit
- rewind_actions
PolyGPT
World state actions
- http.sendRequest
- http.post
- http.get
- filesystem.writeFile
- ethers.sendRpc
Internal actions
- LearnWrap
- InvokeWrap
Input
The entire LLM response
"""
# Check for the existence of the "function_call" key in the log
function_call_existence = bool(log.get("function_call", None))
if function_call_existence:
# Check if the "function_call" key exists and has a "name" key
if "name" in log["function_call"]:
function_name = log["function_call"]["name"]
# List of function names that signify an action
action_function_names = [
"get_html_content",
"read_file",
"write_file",
"wolfram_alpha_query",
"write_python_code",
"execute_python_file",
"google_search",
"wikipedia",
"http.sendRequest",
"http.post",
"http.get",
"filesystem.writeFile",
"ethers.sendRpc",
]
# Check if the function name matches any in the list
return function_name in action_function_names
return False
def is_action_miniagi(log):
"""Mini-AGI function calls are determined by the presence of different patterns
World state actions
- execute_python
- web_search
Internal actions
- done
- talk_to_user
"""
# List of function names that signify an action
action_function_names = ["execute_python", "web_search"]
# Check for the <c>...</c> pattern and whether it matches any action function names
c_pattern_match = False
c_pattern_search = re.search(r"<c>(.*?)<\/c>", log)
if c_pattern_search:
c_pattern_match = c_pattern_search.group(1) in action_function_names
# Check for the "ACTION:" pattern and whether it matches any action function names
action_pattern_match = False
action_pattern_search = re.search(r"ACTION:\s*(\w+)\s*(\(x\d+\))?", log)
if action_pattern_search:
action_pattern_match = action_pattern_search.group(1) in action_function_names
return c_pattern_match or action_pattern_match
def is_action_turbo(log):
"""Turbos actions are defined by the presence of the "cmd" key.
World state actions
- search
- www
- py
- aol
- put
- pyf
Internal actions
- end
"""
# List of function names that signify an action
action_function_names = ["search", "www", "py", "aol", "put", "pyf"]
# Check for the "cmd" key pattern and whether its "name" field matches any action function names
cmd_pattern_match = False
cmd_pattern_search = re.search(r'"cmd"\s*:\s*{\s*"name"\s*:\s*"(\w+)"', log)
if cmd_pattern_search:
cmd_pattern_match = cmd_pattern_search.group(1) in action_function_names
return cmd_pattern_match
def is_action_general(log):
"""General actions are defined by the presence of specific keywords such as 'write', 'start', 'create', etc."""
return bool(
re.search(
r"\b(write|start|create|execute|post|modify|mutate|delete|put|search|find|get|browse|query|www|read|list)\b",
log,
)
)
# post, get, put, delete
"""KEYWORDS FOUND SO FAR
WRITE
- write
- start
- create
- execute
- post
MODIFY
- modify
- mutate
- delete
- put
SEARCH
- search
- find
- get
- browse
- query
- www
READ
- read
- list
GENERAL, no specificity
- command
- call
- function
- action
"""
def is_action_agent(log, agent="", test="", response=""):
"""Determines if a log contains an action based on patterns from different agents."""
is_action = False
if log is None:
print("Log is None", agent, test, response)
return is_action
log_content = log.get("content", "")
if agent == "auto-gpt":
is_action = is_action_auto_gpt(log_content)
elif agent in ["beebot", "polygpt"]:
is_action = is_openai_function(log)
elif agent == "miniagi":
is_action = is_action_miniagi(log_content)
elif agent == "turbo":
is_action = is_action_turbo(log_content)
return is_action

129
paper/combined_data.ipynb
View File

@@ -622,71 +622,29 @@
},
{
"cell_type": "code",
"execution_count": 100,
"execution_count": 61,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"from collections import OrderedDict\n",
"\n",
"\n",
"# Convert the JSON-like strings in the 'response' column to nested dictionaries\n",
"def nested_json(x):\n",
" if pd.notna(x):\n",
" d = json.loads(x) # Convert the string to a dict\n",
" if \"content\" in d and isinstance(d[\"content\"], str):\n",
" try:\n",
" d[\"content\"] = json.loads(d[\"content\"]) # Try converting 'content' to a dict\n",
" except json.JSONDecodeError:\n",
" pass # If it's not JSON, leave it as is\n",
" return d\n",
" return x\n",
"\n",
"\n",
"# Initialize an empty dictionary\n",
"response_dict = OrderedDict()\n",
"response_nested_dict = OrderedDict()\n",
"\n",
"# Get the total number of rows\n",
"total_rows = len(selected_df)\n",
"\n",
"# Loop over the DataFrame's index and rows\n",
"for i, (_, row) in enumerate(selected_df.iterrows()):\n",
" # Convert the JSON-like strings in the 'response' to nested dictionaries\n",
" response = json.loads(row['response'])\n",
" response_nested = nested_json(row['response'])\n",
" \n",
" # Insert the record into the dictionary with the row number as the key\n",
" response_dict[str(total_rows - i)] = response\n",
" response_nested_dict[str(total_rows - i)] = response_nested\n",
" \n",
"# Reverse the order of items in the OrderedDict\n",
"reversed_response_dict = OrderedDict(reversed(list(response_dict.items())))\n",
"reversed_response_nested_dict = OrderedDict(reversed(list(response_nested_dict.items())))\n",
"\n",
"# Write the dictionary to a JSON file\n",
"with open('selected_logs.json', 'w') as f:\n",
" json.dump(reversed_response_dict, f, indent=4)\n",
" \n",
"# Write the dictionary to a JSON file\n",
"with open('selected_logs_nested.json', 'w') as f:\n",
" json.dump(reversed_response_nested_dict, f, indent=4)\n",
"\n",
"# # Show the 'response' column\n",
"# print(response_column.head(5))"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"outputs": [
{
"ename": "TypeError",
"evalue": "loads() missing 1 required positional argument: 's'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[1;32mIn[61], line 43\u001b[0m\n\u001b[0;32m 40\u001b[0m total_rows \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(group)\n\u001b[0;32m 42\u001b[0m \u001b[39mfor\u001b[39;00m i, (_, row) \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(group\u001b[39m.\u001b[39miterrows()):\n\u001b[1;32m---> 43\u001b[0m response \u001b[39m=\u001b[39m json\u001b[39m.\u001b[39;49mloads()\n\u001b[0;32m 44\u001b[0m response_nested \u001b[39m=\u001b[39m nested_json(row[request_type])\n\u001b[0;32m 46\u001b[0m response_dict[\u001b[39mstr\u001b[39m(total_rows\u001b[39m-\u001b[39mi)] \u001b[39m=\u001b[39m response \u001b[39m# Starting from 1 as you mentioned\u001b[39;00m\n",
"\u001b[1;31mTypeError\u001b[0m: loads() missing 1 required positional argument: 's'"
]
}
],
"source": [
"import pandas as pd\n",
"import json\n",
"import os\n",
"from collections import OrderedDict\n",
"\n",
"# from .agent_action_regex import is_action\n",
"\n",
"# Function to convert JSON-like strings to nested dictionaries\n",
"def nested_json(x):\n",
" if pd.notna(x):\n",
@@ -700,13 +658,16 @@
" return x\n",
"\n",
"challenge = \"TestThreeSum\"\n",
"agent_array = ['beebot'] # df['agent'].unique()\n",
"request_type = 'request' # 'request' or 'response'\n",
"\n",
"# Loop through unique agents\n",
"for agent in df['agent'].unique():\n",
"for agent in agent_array:\n",
" selected_df = df.loc[(df['agent'] == agent) & (df['challenge'] == challenge)]\n",
" \n",
" master_response_dict = OrderedDict()\n",
" master_response_nested_dict = OrderedDict()\n",
" master_actions_dict = OrderedDict()\n",
"\n",
" # Group by 'benchmark_start_time'\n",
" grouped_df = selected_df.groupby('benchmark_start_time')\n",
@@ -714,36 +675,68 @@
" for timestamp, group in grouped_df:\n",
" response_dict = OrderedDict()\n",
" response_nested_dict = OrderedDict()\n",
" actions_dict = OrderedDict()\n",
" \n",
" total_rows = len(group)\n",
" \n",
" for i, (_, row) in enumerate(group.iterrows()):\n",
" response = json.loads(row['response'])\n",
" response_nested = nested_json(row['response'])\n",
" if request_type == 'response':\n",
" response = json.loads(row['response'])\n",
" response_nested = nested_json(row['response'])\n",
" \n",
" response_nested_dict[str(total_rows-i)] = response_nested\n",
" else:\n",
" response = row['request']\n",
" \n",
" response_dict[str(total_rows-i)] = response # Starting from 1 as you mentioned\n",
" response_nested_dict[str(total_rows-i)] = response_nested\n",
" \n",
" if request_type == 'response' and is_action_agent(response, agent, challenge, response):\n",
" actions_dict[str(total_rows-i)] = response\n",
" \n",
" if request_type == 'response':\n",
" response_nested_dict = OrderedDict(reversed(list(response_nested_dict.items())))\n",
" actions_dict = OrderedDict(reversed(list(actions_dict.items())))\n",
" \n",
" master_response_nested_dict[str(timestamp)] = response_nested_dict\n",
" master_actions_dict[str(timestamp)] = actions_dict\n",
" \n",
" # Reverse the order within each timestamp group\n",
" response_dict = OrderedDict(reversed(list(response_dict.items())))\n",
" response_nested_dict = OrderedDict(reversed(list(response_nested_dict.items())))\n",
"\n",
" # Add the timestamp as a key to the master dictionary\n",
" master_response_dict[str(timestamp)] = response_dict\n",
" master_response_nested_dict[str(timestamp)] = response_nested_dict\n",
" \n",
" \n",
" # Create directories\n",
" os.makedirs(f'{challenge}', exist_ok=True)\n",
" os.makedirs(f'{challenge}/{agent}', exist_ok=True)\n",
" \n",
" # Write to a JSON file specific to the agent\n",
" with open(f'{challenge}/{agent}/selected_logs.json', 'w') as f:\n",
" with open(f'{challenge}/{agent}/selected_logs_{request_type}.json', 'w') as f:\n",
" json.dump(master_response_dict, f, indent=4)\n",
" \n",
" with open(f'{challenge}/{agent}/selected_logs_nested.json', 'w') as f:\n",
" json.dump(master_response_nested_dict, f, indent=4)\n"
" \n",
" if request_type == 'response':\n",
" with open(f'{challenge}/{agent}/flagged_actions.json', 'w') as f:\n",
" json.dump(master_actions_dict, f, indent=4)\n",
" \n",
" with open(f'{challenge}/{agent}/selected_logs_nested_response.json', 'w') as f:\n",
" json.dump(master_response_nested_dict, f, indent=4)"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,