diff --git a/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_high.csv b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_high.csv new file mode 100644 index 0000000..b6782fa --- /dev/null +++ b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_high.csv @@ -0,0 +1,39 @@ +number_params,error_rate,incorrect_inputs +1,1.0,1 +2,0.0,0 +3,0.0,0 +4,0.25,1 +5,0.6,3 +6,0.3333333333333333,2 +7,0.14285714285714285,1 +8,0.5,4 +9,0.4444444444444444,4 +10,0.1,1 +11,0.2727272727272727,3 +12,0.08333333333333333,1 +13,0.38461538461538464,5 +14,0.0,0 +15,0.4,6 +16,0.0625,1 +17,0.17647058823529413,3 +18,0.3333333333333333,6 +19,0.2631578947368421,5 +20,0.25,5 +21,0.38095238095238093,8 +22,0.3181818181818182,7 +23,0.21739130434782608,5 +24,0.3333333333333333,8 +25,0.28,7 +26,0.2692307692307692,7 +27,0.3333333333333333,9 +28,0.32142857142857145,9 +29,0.27586206896551724,8 +30,0.3,9 +31,0.12903225806451613,4 +32,0.28125,9 +33,0.48484848484848486,16 +34,0.2647058823529412,9 +35,0.17142857142857143,6 +36,0.3055555555555556,11 +37,0.13513513513513514,5 +38,0.3157894736842105,12 diff --git a/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_mid.csv b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_mid.csv new file mode 100644 index 0000000..278fbc0 --- /dev/null +++ b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_mid.csv @@ -0,0 +1,39 @@ +number_params,error_rate,incorrect_inputs +1,0.0,0 +2,0.0,0 +3,0.6666666666666666,2 +4,0.0,0 +5,0.0,0 +6,0.16666666666666666,1 +7,0.0,0 +8,0.25,2 +9,0.2222222222222222,2 +10,0.3,3 +11,0.18181818181818182,2 +12,0.3333333333333333,4 +13,0.07692307692307693,1 +14,0.14285714285714285,2 +15,0.0,0 +16,0.25,4 +17,0.058823529411764705,1 +18,0.05555555555555555,1 +19,0.10526315789473684,2 +20,0.15,3 +21,0.2857142857142857,6 +22,0.5,11 +23,0.34782608695652173,8 +24,0.20833333333333334,5 +25,0.16,4 +26,0.23076923076923078,6 +27,0.25925925925925924,7 +28,0.14285714285714285,4 +29,0.2413793103448276,7 +30,0.16666666666666666,5 +31,0.12903225806451613,4 +32,0.3125,10 +33,0.3939393939393939,13 +34,0.4411764705882353,15 +36,0.16666666666666666,6 +37,0.35135135135135137,13 +38,0.2894736842105263,11 +39,0.20512820512820512,8 diff --git a/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv new file mode 100644 index 0000000..31b5cbc --- /dev/null +++ b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv @@ -0,0 +1,40 @@ +number_params,error_rate,incorrect_inputs +1,0.0,0 +2,0.0,0 +3,0.3333333333333333,1 +4,0.5,2 +5,0.0,0 +6,0.3333333333333333,2 +7,0.14285714285714285,1 +8,0.0,0 +9,0.2222222222222222,2 +10,0.2,2 +11,0.2727272727272727,3 +12,0.08333333333333333,1 +13,0.23076923076923078,3 +14,0.21428571428571427,3 +15,0.06666666666666667,1 +16,0.125,2 +17,0.058823529411764705,1 +18,0.05555555555555555,1 +19,0.15789473684210525,3 +20,0.1,2 +21,0.19047619047619047,4 +22,0.13636363636363635,3 +23,0.08695652173913043,2 +24,0.125,3 +25,0.12,3 +26,0.15384615384615385,4 +27,0.14814814814814814,4 +28,0.14285714285714285,4 +29,0.13793103448275862,4 +30,0.2,6 +31,0.12903225806451613,4 +32,0.125,4 +33,0.15151515151515152,5 +34,0.14705882352941177,5 +35,0.08571428571428572,3 +36,0.1388888888888889,5 +37,0.10810810810810811,4 +38,0.10526315789473684,4 +39,0.10256410256410256,4 diff --git a/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_high.csv b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_high.csv new file mode 100644 index 0000000..665261a --- /dev/null +++ b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_high.csv @@ -0,0 +1,40 @@ +number_params,error_rate,incorrect_inputs +1,1.0,1 +2,0.0,0 +3,0.3333333333333333,1 +4,0.25,1 +5,0.0,0 +6,0.16666666666666666,1 +7,0.14285714285714285,1 +8,0.125,1 +9,0.2222222222222222,2 +10,0.2,2 +11,0.0,0 +12,0.3333333333333333,4 +13,0.15384615384615385,2 +14,0.0,0 +15,0.13333333333333333,2 +16,0.125,2 +17,0.11764705882352941,2 +18,0.1111111111111111,2 +19,0.05263157894736842,1 +20,0.15,3 +21,0.19047619047619047,4 +22,0.13636363636363635,3 +23,0.17391304347826086,4 +24,0.08333333333333333,2 +25,0.08,2 +26,0.2692307692307692,7 +27,0.07407407407407407,2 +28,0.10714285714285714,3 +29,0.06896551724137931,2 +30,0.13333333333333333,4 +31,0.16129032258064516,5 +32,0.375,12 +33,0.15151515151515152,5 +34,0.14705882352941177,5 +35,0.08571428571428572,3 +36,0.1111111111111111,4 +37,0.2972972972972973,11 +38,0.2894736842105263,11 +39,0.1282051282051282,5 diff --git a/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_low.csv b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_low.csv new file mode 100644 index 0000000..57de6db --- /dev/null +++ b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_low.csv @@ -0,0 +1,40 @@ +number_params,error_rate,incorrect_inputs +1,1.0,1 +2,0.5,1 +3,0.0,0 +4,0.5,2 +5,0.0,0 +6,0.16666666666666666,1 +7,0.0,0 +8,0.125,1 +9,0.0,0 +10,0.2,2 +11,0.09090909090909091,1 +12,0.16666666666666666,2 +13,0.15384615384615385,2 +14,0.21428571428571427,3 +15,0.06666666666666667,1 +16,0.0625,1 +17,0.11764705882352941,2 +18,0.05555555555555555,1 +19,0.15789473684210525,3 +20,0.15,3 +21,0.09523809523809523,2 +22,0.045454545454545456,1 +23,0.17391304347826086,4 +24,0.2916666666666667,7 +25,0.08,2 +26,0.038461538461538464,1 +27,0.14814814814814814,4 +28,0.17857142857142858,5 +29,0.10344827586206896,3 +30,0.13333333333333333,4 +31,0.16129032258064516,5 +32,0.09375,3 +33,0.15151515151515152,5 +34,0.14705882352941177,5 +35,0.08571428571428572,3 +36,0.1388888888888889,5 +37,0.13513513513513514,5 +38,0.10526315789473684,4 +39,0.1282051282051282,5 diff --git a/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_mid.csv b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_mid.csv new file mode 100644 index 0000000..a3eb65d --- /dev/null +++ b/experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_mid.csv @@ -0,0 +1,40 @@ +number_params,error_rate,incorrect_inputs +1,0.0,0 +2,0.0,0 +3,0.0,0 +4,0.25,1 +5,0.0,0 +6,0.3333333333333333,2 +7,0.14285714285714285,1 +8,0.25,2 +9,0.3333333333333333,3 +10,0.1,1 +11,0.09090909090909091,1 +12,0.16666666666666666,2 +13,0.15384615384615385,2 +14,0.14285714285714285,2 +15,0.13333333333333333,2 +16,0.125,2 +17,0.11764705882352941,2 +18,0.05555555555555555,1 +19,0.10526315789473684,2 +20,0.1,2 +21,0.19047619047619047,4 +22,0.36363636363636365,8 +23,0.17391304347826086,4 +24,0.08333333333333333,2 +25,0.08,2 +26,0.11538461538461539,3 +27,0.2222222222222222,6 +28,0.07142857142857142,2 +29,0.06896551724137931,2 +30,0.16666666666666666,5 +31,0.06451612903225806,2 +32,0.125,4 +33,0.12121212121212122,4 +34,0.14705882352941177,5 +35,0.11428571428571428,4 +36,0.1111111111111111,4 +37,0.13513513513513514,5 +38,0.13157894736842105,5 +39,0.1282051282051282,5 diff --git a/experiments/max_params_per_tool/max_param_analysis.ipynb b/experiments/max_params_per_tool/max_param_analysis.ipynb new file mode 100644 index 0000000..8e35c0f --- /dev/null +++ b/experiments/max_params_per_tool/max_param_analysis.ipynb @@ -0,0 +1,1121 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of the Max params" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "module_path = os.path.abspath(os.path.join('..','..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + "from experiments.tools import GenerateParam, ArbitraryClientTool\n", + "from experiments.max_params_per_tool.max_params_per_tool import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generating 50 params to be used for the Abritrary Client Tool" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 1: name temperature, type:float, description:The temperature of the environment.\n", + "Parameter 2: name humidity, type:int, description:The humidity level of the air.\n", + "Parameter 3: name pressure, type:bool, description:Whether the pressure is high or low.\n", + "Parameter 4: name altitude, type:str, description:The altitude of the location.\n", + "Parameter 5: name speed, type:float, description:The speed of the object.\n", + "Parameter 6: name location, type:str, description:The location of the object.\n", + "Parameter 7: name time, type:int, description:The time of day.\n", + "Parameter 8: name direction, type:str, description:The direction of travel.\n", + "Parameter 9: name distance, type:float, description:The distance traveled.\n", + "Parameter 10: name speed_limit, type:int, description:The speed limit of the road.\n", + "Parameter 11: name fuel_level, type:float, description:The fuel level of the vehicle.\n", + "Parameter 12: name fuel_efficiency, type:float, description:The fuel efficiency of the vehicle.\n", + "Parameter 13: name engine_size, type:int, description:The size of the engine.\n", + "Parameter 14: name horsepower, type:int, description:The horsepower of the engine.\n", + "Parameter 15: name torque, type:float, description:The torque of the engine.\n", + "Parameter 16: name transmission_type, type:str, description:The type of transmission.\n", + "Parameter 17: name gear_ratio, type:float, description:The gear ratio of the transmission.\n", + "Parameter 18: name brake_type, type:str, description:The type of brake system.\n", + "Parameter 19: name suspension_type, type:str, description:The type of suspension system.\n", + "Parameter 20: name steering_type, type:str, description:The type of steering system.\n", + "Parameter 21: name seat_type, type:str, description:The type of seat.\n", + "Parameter 22: name airbag_type, type:str, description:The type of airbag system.\n", + "Parameter 23: name anti_lock_brake_system, type:str, description:The type of anti-lock brake system.\n", + "Parameter 24: name electronic_stability_control, type:str, description:The type of electronic stability control system.\n", + "Parameter 25: name lane_departure_warning, type:str, description:The type of lane departure warning system.\n", + "Parameter 26: name adaptive_cruise_control, type:str, description:The type of adaptive cruise control system.\n", + "Parameter 27: name blind_spot_monitor, type:str, description:The type of blind spot monitor system.\n", + "Parameter 28: name rear_view_camera, type:str, description:The type of rear view camera system.\n", + "Parameter 29: name parking_sensors, type:str, description:The type of parking sensors system.\n", + "Parameter 30: name keyless_entry, type:str, description:The type of keyless entry system.\n", + "Parameter 31: name push_start_button, type:str, description:The type of push start button system.\n", + "Parameter 32: name remote_start, type:str, description:The type of remote start system.\n", + "Parameter 33: name smartphone_app, type:str, description:The type of smartphone app system.\n", + "Parameter 34: name voice_command, type:str, description:The type of voice command system.\n", + "Parameter 35: name navigation_system, type:str, description:The type of navigation system.\n", + "Parameter already exists\n", + "Parameter already exists\n", + "Parameter already exists\n", + "Parameter already exists\n", + "Parameter already exists\n", + "Parameter 41: name automatic_emergency_braking, type:str, description:The type of automatic emergency braking system.\n", + "Parameter 42: name lane_centering, type:str, description:The type of lane centering system.\n", + "Parameter 43: name traffic_sign_recognition, type:str, description:The type of traffic sign recognition system.\n", + "Parameter 44: name driver_monitoring, type:str, description:The type of driver monitoring system.\n", + "Parameter 45: name parking_sonar, type:str, description:The type of parking sonar system.\n", + "Parameter 46: name 360_degree_camera, type:str, description:The type of 360 degree camera system.\n", + "Parameter already exists\n", + "Parameter 48: name blind_spot_monitoring, type:str, description:The type of blind spot monitoring system.\n", + "Parameter already exists\n", + "Parameter already exists\n" + ] + } + ], + "source": [ + "all_params = get_params(50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Removing any duplicate parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data cleaned (duplicates removed): \n", + "\n", + "name ['temperature', 'humidity', 'pressure', 'altitude', 'speed', 'location', 'time', 'direction', 'distance', 'speed_limit', 'fuel_level', 'fuel_efficiency', 'engine_size', 'horsepower', 'torque', 'transmission_type', 'gear_ratio', 'brake_type', 'suspension_type', 'steering_type', 'seat_type', 'airbag_type', 'anti_lock_brake_system', 'electronic_stability_control', 'lane_departure_warning', 'adaptive_cruise_control', 'blind_spot_monitor', 'rear_view_camera', 'parking_sensors', 'keyless_entry', 'push_start_button', 'remote_start', 'smartphone_app', 'voice_command', 'navigation_system', 'automatic_emergency_braking', 'lane_centering', 'traffic_sign_recognition', 'driver_monitoring', 'parking_sonar', '360_degree_camera', 'blind_spot_monitoring']\n", + "type ['float', 'int', 'bool', 'str', 'float', 'str', 'int', 'str', 'float', 'int', 'float', 'float', 'int', 'int', 'float', 'str', 'float', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str', 'str']\n", + "description ['The temperature of the environment.', 'The humidity level of the air.', 'Whether the pressure is high or low.', 'The altitude of the location.', 'The speed of the object.', 'The location of the object.', 'The time of day.', 'The direction of travel.', 'The distance traveled.', 'The speed limit of the road.', 'The fuel level of the vehicle.', 'The fuel efficiency of the vehicle.', 'The size of the engine.', 'The horsepower of the engine.', 'The torque of the engine.', 'The type of transmission.', 'The gear ratio of the transmission.', 'The type of brake system.', 'The type of suspension system.', 'The type of steering system.', 'The type of seat.', 'The type of airbag system.', 'The type of anti-lock brake system.', 'The type of electronic stability control system.', 'The type of lane departure warning system.', 'The type of adaptive cruise control system.', 'The type of blind spot monitor system.', 'The type of rear view camera system.', 'The type of parking sensors system.', 'The type of keyless entry system.', 'The type of push start button system.', 'The type of remote start system.', 'The type of smartphone app system.', 'The type of voice command system.', 'The type of navigation system.', 'The type of automatic emergency braking system.', 'The type of lane centering system.', 'The type of traffic sign recognition system.', 'The type of driver monitoring system.', 'The type of parking sonar system.', 'The type of 360 degree camera system.', 'The type of blind spot monitoring system.']\n" + ] + } + ], + "source": [ + "\n", + "\n", + "# To track seen names and their indices\n", + "seen_names = set()\n", + "indices_to_remove = []\n", + "\n", + "# Iterate over the 'name' list\n", + "for i in range(len(all_params['name'])):\n", + " if all_params['name'][i] in seen_names:\n", + " # Mark the index for removal if name is duplicated\n", + " print(f\"Duplicate name found: {all_params['name'][i]}\")\n", + " indices_to_remove.append(i)\n", + " else:\n", + " # Otherwise, add to the set of seen names\n", + " seen_names.add(all_params['name'][i])\n", + "\n", + "# Remove the entries that have duplicates in 'name'\n", + "all_params['name'] = [all_params['name'][i] for i in range(len(all_params['name'])) if i not in indices_to_remove]\n", + "all_params['type'] = [all_params['type'][i] for i in range(len(all_params['type'])) if i not in indices_to_remove]\n", + "all_params['description'] = [all_params['description'][i] for i in range(len(all_params['description'])) if i not in indices_to_remove]\n", + "\n", + "# Output the cleaned all_params\n", + "print(\"Data cleaned (duplicates removed): \\n\")\n", + "for param in all_params:\n", + " print(param, all_params[param])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "42\n" + ] + } + ], + "source": [ + "print(len(all_params['name']))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter checks completed.\n", + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter checks completed.\n", + "3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter checks completed.\n", + "4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter checks completed.\n", + "5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter checks completed.\n", + "6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "7\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter checks completed.\n", + "9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "11\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter checks completed.\n", + "12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter checks completed.\n", + "13\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "14\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "15\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "17\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "18\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "19\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "21\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "22\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "23\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "24\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "26\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "27\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "28\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "29\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "31\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "32\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "33\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "34\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "35\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "36\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "37\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "38\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`agent_config` is deprecated. Use inlined parameters instead.\n", + "`client_tools` is deprecated. Use `tools` instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "39\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n" + ] + } + ], + "source": [ + "import random\n", + "retry = False\n", + "acc_dict = {}\n", + "for i in range(1, 40):\n", + " error_count = 0\n", + " # Get random indices from the range of the sliced lists\n", + " random_indices = random.sample(range(len(all_params['name'])), i)\n", + " if retry:\n", + " i = i - 1\n", + " # Select the corresponding names, types, and descriptions using the random indices\n", + " selected_params = {\n", + " 'name': [all_params['name'][idx] for idx in random_indices],\n", + " 'type': [all_params['type'][idx] for idx in random_indices],\n", + " 'description': [all_params['description'][idx] for idx in random_indices]\n", + " }\n", + " print(\n", + " len(selected_params['name']))\n", + " response = test_abitrary_client_tool(selected_params)\n", + " steps = response.steps\n", + " # for step in steps:\n", + " # print(step)\n", + " try:\n", + " params_used = steps[1].tool_calls[0].arguments\n", + "\n", + " for param_name, param_value in params_used.items():\n", + " index = selected_params['name'].index(param_name)\n", + " expected_type = selected_params['type'][index]\n", + " \n", + " # Check if the type matches the expected type\n", + " if not isinstance(param_value, eval(expected_type)):\n", + " print(f\"Parameter '{param_name}' has an invalid type. Expected '{expected_type}', but got '{type(param_value).__name__}'.\")\n", + " error_count += 1\n", + " acc_dict[i] = error_count\n", + " retry = False \n", + " except:\n", + " print(\"Error with the tool\")\n", + " retry = True\n", + " continue\n", + " print(\"Parameter checks completed.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graph showing the number of hullicination" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Example dictionary with numerical keys and values\n", + "\n", + "# Extract keys and values\n", + "keys = list(acc_dict.keys())\n", + "values = list(acc_dict.values())\n", + "\n", + "# Create a plot\n", + "plt.figure(figsize=(8, 5))\n", + "\n", + "# Plot the values\n", + "plt.plot(keys, values, marker='o', linestyle='-', color='b', label='Values')\n", + "\n", + "# Label the axes\n", + "plt.xlabel('Number of total parameters')\n", + "plt.ylabel('Number of Hallucinated Parameters')\n", + "\n", + "# Add a title to the plot\n", + "plt.title('Number of Halluncinated Parameters')\n", + "\n", + "# Optionally, add gridlines for better visibility\n", + "plt.grid(True)\n", + "\n", + "# Show the plot\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graph of Error rate for each number of parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "import numpy as np\n", + "\n", + "# Compute error rate (errors/params)\n", + "error_rate = {key: value / key for key, value in acc_dict.items()}\n", + "\n", + "# Extract keys (total params) and values (error rates)\n", + "keys = list(error_rate.keys())\n", + "values = list(error_rate.values())\n", + "\n", + "# Create a plot\n", + "plt.figure(figsize=(8, 5))\n", + "\n", + "# Plot the error rates\n", + "plt.plot(keys, values, marker='o', linestyle='-', color='r', label='Error Rate')\n", + "\n", + "# Label the axes\n", + "plt.xlabel('Total Number of Parameters (X-axis)')\n", + "plt.ylabel('Error Rate (Y-axis)')\n", + "\n", + "# Add a title to the plot\n", + "plt.title('Error Rate vs. Total Number of Parameters')\n", + "\n", + "# Optionally, add gridlines for better visibility\n", + "plt.grid(True)\n", + "\n", + "# Show the plot\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Saving data" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data has been written to experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv\n" + ] + } + ], + "source": [ + "import os\n", + "import csv\n", + "\n", + "## Combine error_rate and acc_dict into a list of rows\n", + "combined_data = []\n", + "for key in error_rate:\n", + " if key in acc_dict: # Check if key is in both dictionaries\n", + " combined_data.append([key, error_rate[key], acc_dict[key]])\n", + "\n", + "# Define the file path\n", + "file_path = 'experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv'\n", + "\n", + "# Ensure the directory exists, create if it doesn't\n", + "os.makedirs(os.path.dirname(file_path), exist_ok=True)\n", + "\n", + "# Write to CSV file with explicit delimiter (comma)\n", + "with open(file_path, mode='w', newline='', encoding='utf-8') as file:\n", + " writer = csv.writer(file, delimiter=',') # Ensure comma is the delimiter\n", + " # Write the header for table\n", + " writer.writerow([\"number_params\", \"error_rate\", \"incorrect_inputs\"])\n", + " # Write the data rows (this will form the table)\n", + " writer.writerows(combined_data)\n", + "\n", + "print(f\"Data has been written to {file_path}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/experiments/max_params_per_tool/max_params_per_tool.py b/experiments/max_params_per_tool/max_params_per_tool.py index 874ae4a..5166420 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -2,42 +2,102 @@ from llama_stack_client.lib.agents.agent import Agent from llama_stack_client.types.agent_create_params import AgentConfig from llama_stack_client import LlamaStackClient - -from ..tools import ArbitraryClientTool - +from ..tools import ArbitraryClientTool, GenerateParam +import json +import ast client = LlamaStackClient(base_url="http://localhost:8321") -for i in range(15,30,5): - print(i) - - arbitrary_client_tool = ArbitraryClientTool(i) - print(arbitrary_client_tool.get_tool_definition()) +# GENERATE PARAM TOOL +def get_params(i): + generate_param_tool = GenerateParam("param","str","This is a parameter") - agent_config = AgentConfig( + agent_param = Agent(client, model="meta-llama/Llama-3.1-8B-Instruct", enable_session_persistence = False, - instructions = "You are a helpful assistant.", - toolgroups = [], - client_tools = [arbitrary_client_tool.get_tool_definition()], - tool_choice="required", - tool_prompt_format="json", - max_infer_iters=4, - ) - - agent = Agent(client=client, + instructions = """You are a Parameter generator assistant. Use the GenerateParam tool to generate realistic and random parameters for a function that will be created. + When using the generate_param_tool tool: + 1. Select a parameter type (str/bool/int/float) for it. + 3. For the randomly selected parameter type create a realistic name different to previous params to match the parameter type, and a description based on a random topic. + 4. Pass these the name, parameter type and description in to the generate_param_tool + """, + tools=[generate_param_tool], + ) + all_params = {"name": [], "type": [], "description": []} + + session_id = agent_param.create_session("test") + for count in range(i): + response = agent_param.create_turn( + messages=[{"role":"user","content":"use the generate_param_tool and pass in a name, type, and description"}], + session_id= session_id, + stream=False, + ) + steps = response.steps + param = steps[1].tool_calls[0].arguments['param'] + if isinstance(param, str): + try: + # Attempt to convert the string to a dictionary (assuming it's a JSON string) + param = ast.literal_eval(param) + except (ValueError, SyntaxError): + print("Error: The string is not a valid dictionary format.") + + + name = param.get('name', 'Not Available') + param_tpy = param.get('type', 'Not Available') + description = param.get('description', 'Not Available') + + if name in all_params['name']: + print("Parameter already exists") + i = i - 1 + else: + print(f"Parameter {count+1}: name {name}, type:{param_tpy}, description:{description}") + all_params["name"].append(name) + all_params["type"].append(param_tpy) + all_params["description"].append(description) + + return all_params + +def test_abitrary_client_tool(all_params): + arbitrary_client_tool = ArbitraryClientTool(all_params) + + arb_client = LlamaStackClient(base_url="http://llamastack-deployment-llama-serve.apps.ocp-beta-test.nerc.mghpcc.org:80") + + agent_config = AgentConfig( + model="meta-llama/Llama-3.2-3B-Instruct", + enable_session_persistence = False, + instructions = "You are a helpful assistant. Use the ArbitraryClientTool and pass in a value for each parameter according to its type.", + sampling_params = { + "strategy": { + "type": "top_p", + "temperature": 0.001, + "top_p": 0.9, + } + }, + toolgroups=[], + client_tools = [arbitrary_client_tool.get_tool_definition()], + tool_choice="auto", + # note: the below works for llama-3.1-8B model, but if you plan to use the + # llama-3.2-3B model, you will need to change it to tool_prompt_format="python_list" + tool_prompt_format="python_list", + ) + agent = Agent(client = arb_client, agent_config=agent_config, client_tools=[arbitrary_client_tool] ) session_id = agent.create_session("test") response = agent.create_turn( - messages=[{"role":"user","content":"You must use the arbitrary_client_tool"}], + messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters according to their type"}], session_id= session_id, + stream=False, ) + return response - for r in EventLogger().log(response): - r.print() - - print("\n") +def main(): + all_params = get_params(1) + response = test_abitrary_client_tool(all_params) + for step in response.steps: + print(step) +if __name__ == "__main__": + main() diff --git a/experiments/tools.py b/experiments/tools.py index aec4a81..19dc36f 100644 --- a/experiments/tools.py +++ b/experiments/tools.py @@ -3,30 +3,74 @@ class ArbitraryClientTool(ClientTool): - def __init__(self, n): - self.n = n + """AbitraryClientTool is a tool that returns the parameters passed to it. + The agent checks the parameter type of each parameter and the passes a value based on that parameter type. + :param all_params: A dictionary containing the parameters to be returned. + :return: The parameters passed to the tool. + """ + def __init__(self, all_params): + self.all_params = all_params def _arbitrary_tool(self, *kwargs): return kwargs - def _generate_kwargs(self, num:int) -> dict: - kwargs = {f"query_{n}": Parameter( - name=f"query_{n}", - parameter_type="str", - description=f"query_{n}", + def _generate_kwargs(self, all_params) -> dict: + kwargs = {f"param_{i}": Parameter( + name=all_params["name"][i], + parameter_type=all_params["type"][i], + description=all_params["description"][i], + required=True, + ) for i in range(len(all_params["name"]))} + return kwargs + + def get_name(self): + return "arbitrary_client_tool" + + def get_description(self): + return "This tool is used to evaluate the number of parameters an LLM can manage during tool calling." + + def get_params_definition(self): + return self._generate_kwargs(self.all_params) + + def run_impl(self, **kwargs): + return self._arbitrary_tool(kwargs) + + +class GenerateParam(ClientTool): + """GenerateParam is a tool that generates a random realistic parameter. + + :param name: The name of the parameter. + :param parameter_type: The type of the parameter. + :param description: The description of the parameter. + :returns: A random realistic parameter. + """ + + def __init__(self, name, parameter_type, description): + self.name = name + self.parameter_type = parameter_type + self.description = description + + def _arbitrary_tool(self, *kwargs): + return kwargs + + def _generate_kwargs(self, name:str,parameter_type:str,description:str) -> dict: + kwargs = {f"Param": Parameter( + name=f"{name}", + parameter_type= f"{parameter_type}", + description=f"{description}", required=True, - ) for n in range(num)} + )} return kwargs def get_name(self): - return "arbitrary_tool" + return "generate_param_tool" def get_description(self): - return "This tool is used to evaluate the number of parameters an LLM can manage during tool calling." + return "This tool generates a random realistic parameter, with a name, type, and description." def get_params_definition(self): - return self._generate_kwargs(self.n) + return self._generate_kwargs(self.name,self.parameter_type,self.description) def run_impl(self, **kwargs): - return self._arbitrary_tool(kwargs) + return self._arbitrary_tool(kwargs) \ No newline at end of file diff --git a/prototype/frameworks/llamastack/README.md b/prototype/frameworks/llamastack/README.md index af457c8..c92049a 100644 --- a/prototype/frameworks/llamastack/README.md +++ b/prototype/frameworks/llamastack/README.md @@ -143,6 +143,60 @@ Run the script: ```bash python scripts/custom-tool.py ``` +--- +## **11. Llama Stack - Logging and Tracing using OpenTelemetry collector and Jaegar.** + +### Overview +The LlamaStack Metric Telemetry API provides robust functionalities for logging and tracing spans during workflows. Proper configuration is essential for efficient monitoring and tracking. + +### 1. Update the `run.yaml` Configuration + +Modify the configuration to include telemetry sinks, otel sink works with any service compatible with the OpenTelemetry collector. + +```yaml +telemetry: + - provider_id: meta-reference + provider_type: inline::meta-reference + config: + service_name: ${env.OTEL_SERVICE_NAME:llama-stack} + sinks: ${env.TELEMETRY_SINKS:console, otel, sqlite} + otel_endpoint: "http://localhost:4318/v1/traces" + sqlite_db_path: ${env.SQLITE_DB_PATH:~/.llama/distributions/ollama/trace_store.db} +``` +Additionally, make the necessary adjustments to include more RAG providers required for the specific use case. + +### 3.Run the Llama Stack server + +Run the LlamaStack server using the updated run.yaml configuration file: + +```bash +llama stack run --image-type conda /run.yaml +``` + +### 4.Create a session for each run + +Create a session ID for better tracking of each run. Include the following snippet in your code: + +```python +session_id = agent.create_session("test-session") +print(f"Created session_id={session_id} for Agent({agent.agent_id})") +``` + +### 5.Start Jaegar Instance + +Deploy a Jaeger instance with the OTLP HTTP endpoint exposed at port 4318. Use the following command: + +```bash +podman run --rm --name jaeger \ + -p 16686:16686 -p 4318:4318 \ + jaegertracing/jaeger:2.1.0 +``` + +### 6. Visualise traces + +Access the Jaeger UI to visualize traces by navigating to: http://localhost:16686/ + +--- ## **Run a wolfram-alpha powered Agent** If you wish to test the Wolfram Alpha tool, you can follow the example in `tool_wolframAlpha.py`. This example is necessary to demonstrate how to build an agent based on Wolfram Alpha, as previous documentation examples are outdated. Run it through Podman following the same instructions.