From b8bd35cf3022461f31004c026a662c802115a341 Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Tue, 4 Mar 2025 14:26:14 +0000 Subject: [PATCH 1/9] init --- .../max_params_per_tool.py | 69 ++++++++++--------- 1 file changed, 37 insertions(+), 32 deletions(-) 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..15e03a9 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -9,35 +9,40 @@ 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()) - - agent_config = AgentConfig( - 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, - 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"}], - session_id= session_id, - ) - - for r in EventLogger().log(response): - r.print() - - print("\n") +i = 5 +print(i) + +arbitrary_client_tool = ArbitraryClientTool(i) +print(arbitrary_client_tool.get_tool_definition()) + +agent_config = AgentConfig( + model="meta-llama/Llama-3.2-3B-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="python_list", + max_infer_iters=4, + ) + +agent = Agent(client=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"}], + session_id= session_id, + ) + +for r in EventLogger().log(response): + r.print() + +print("\n") + +result = arbitrary_client_tool.run_impl( query_1="test2", query_2="test3", query_3="test4", query_4="test5") + +# The result will be the same parameters as the input: +print(result) From 5912eae48a715ee98dd294d2a0f1c14fec0294a3 Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Thu, 6 Mar 2025 17:57:08 +0000 Subject: [PATCH 2/9] WIP --- .../max_params_per_tool.py | 95 +++++++++++++------ experiments/tools.py | 43 ++++++++- 2 files changed, 103 insertions(+), 35 deletions(-) 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 15e03a9..6797a23 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -2,47 +2,80 @@ 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 +import json +from ..tools import ArbitraryClientTool, GenerateParam client = LlamaStackClient(base_url="http://localhost:8321") -i = 5 -print(i) - -arbitrary_client_tool = ArbitraryClientTool(i) -print(arbitrary_client_tool.get_tool_definition()) - -agent_config = AgentConfig( - model="meta-llama/Llama-3.2-3B-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="python_list", - max_infer_iters=4, - ) - -agent = Agent(client=client, - agent_config=agent_config, - client_tools=[arbitrary_client_tool] + + +generate_param_tool = GenerateParam("param","str","This is a parameter") +# print(generate_param_tool.get_tool_definition()) +agent_config_param = AgentConfig( +model="meta-llama/Llama-3.1-8B-Instruct", +enable_session_persistence = False, +instructions = """You are a Parameter generator assistant. Use the GenerateParam tool to generate random realistic parameters for a function that will be created. +When using the GenerateParam tool: +1. Create a name, parameter type, and description for the parameters +2. Return the name, parameter type, and description for the parameters +3. Present the result clearly""", +toolgroups = [], +client_tools = [generate_param_tool.get_tool_definition()], +tool_choice="auto", +tool_prompt_format="json", +max_infer_iters=4, +) +agent_param = Agent(client=client, + agent_config=agent_config_param, + client_tools=[generate_param_tool], ) -session_id = agent.create_session("test") -response = agent.create_turn( - messages=[{"role":"user","content":"You must use the arbitrary_client_tool"}], +session_id = agent_param.create_session("test") +response = agent_param.create_turn( + messages=[{"role":"user","content":"use the GenerateParam and pass in a random parameters"}], session_id= session_id, ) -for r in EventLogger().log(response): - r.print() +print("OUTPUT:") +# for r in response: + # print("Inference Output:") + # print(r) +print("\n \n") -print("\n") +# arbitrary_client_tool = ArbitraryClientTool(i) +# print(arbitrary_client_tool.get_tool_definition()) +# agent_config = AgentConfig( +# 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="auto", +# tool_prompt_format="json", +# max_infer_iters=4, +# ) -result = arbitrary_client_tool.run_impl( query_1="test2", query_2="test3", query_3="test4", query_4="test5") +# agent = Agent(client=client, +# agent_config=agent_config, +# client_tools=[arbitrary_client_tool] +# ) -# The result will be the same parameters as the input: -print(result) + # session_id = agent.create_session("test") + # response = agent.create_turn( + # messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters"}], + # session_id= session_id, + # ) +print("OUTPUT:") +ev = "" +for r in EventLogger().log(response): + ev += str(r) +print(ev) + +data = json.loads(ev) +print(data) +# print(abbbs) +# print(response.ToolCall()) +print("END:") +print("\n") diff --git a/experiments/tools.py b/experiments/tools.py index aec4a81..5873fa8 100644 --- a/experiments/tools.py +++ b/experiments/tools.py @@ -10,17 +10,17 @@ def _arbitrary_tool(self, *kwargs): return kwargs def _generate_kwargs(self, num:int) -> dict: - kwargs = {f"query_{n}": Parameter( - name=f"query_{n}", + kwargs = {f"q_{n}": Parameter( + name=f"q_{n}", parameter_type="str", - description=f"query_{n}", + description=f"q_{n}", required=True, ) for n in range(num)} return kwargs def get_name(self): - return "arbitrary_tool" + 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." @@ -30,3 +30,38 @@ def get_params_definition(self): def run_impl(self, **kwargs): return self._arbitrary_tool(kwargs) + + + +# Tool params +# Should +class GenerateParam(ClientTool): + 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, + )} + + return kwargs + + def get_name(self): + return "generate_param_tool" + + def get_description(self): + return "This tool generates a random realistic parameter, with a name, type, and description." + + def get_params_definition(self): + return self._generate_kwargs(self.name,self.parameter_type,self.description) + + def run_impl(self, **kwargs): + return self._arbitrary_tool(kwargs) \ No newline at end of file From 98812c8ed0315756444d1df8ae4be5ff5ec5f172 Mon Sep 17 00:00:00 2001 From: AIMikav <619anamika@gmail.com> Date: Wed, 5 Mar 2025 12:05:31 +0000 Subject: [PATCH 3/9] updated README: added llama stack logging and tracing configurations. --- prototype/frameworks/llamastack/README.md | 54 +++++++++++++++++++++++ 1 file changed, 54 insertions(+) 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. From 727588560f2fce53bb8233f2edab8bdaa915a15e Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Fri, 7 Mar 2025 13:41:39 +0000 Subject: [PATCH 4/9] Working Param Generator tool --- .../max_params_per_tool.py | 101 ++++++++++-------- experiments/tools.py | 15 +-- 2 files changed, 67 insertions(+), 49 deletions(-) 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 6797a23..35a7a0f 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -2,24 +2,23 @@ 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 -import json from ..tools import ArbitraryClientTool, GenerateParam client = LlamaStackClient(base_url="http://localhost:8321") - +# GENERATE PARAM TOOL generate_param_tool = GenerateParam("param","str","This is a parameter") # print(generate_param_tool.get_tool_definition()) agent_config_param = AgentConfig( model="meta-llama/Llama-3.1-8B-Instruct", enable_session_persistence = False, -instructions = """You are a Parameter generator assistant. Use the GenerateParam tool to generate random realistic parameters for a function that will be created. -When using the GenerateParam tool: -1. Create a name, parameter type, and description for the parameters -2. Return the name, parameter type, and description for the parameters +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. Create a name, parameter type, and description for the parameter +2. Pass these into the generate_param_tool 3. Present the result clearly""", toolgroups = [], client_tools = [generate_param_tool.get_tool_definition()], @@ -34,48 +33,64 @@ session_id = agent_param.create_session("test") response = agent_param.create_turn( - messages=[{"role":"user","content":"use the GenerateParam and pass in a random parameters"}], + messages=[{"role":"user","content":"use the generate_param_tool and pass in a realistic and random parameter"}], session_id= session_id, + stream=False, ) -print("OUTPUT:") -# for r in response: - # print("Inference Output:") - # print(r) -print("\n \n") +steps = response.steps +####################################### +############# +# Set Steam = False to use the steps +# for step in steps: +# print(step) +# print("\n") + +# Set Stream = True to use the EventLogger +# for log in EventLogger().log(response): +# log.print() +assert len(steps) == 3 +assert steps[0].step_type == "inference" +assert steps[1].step_type == "tool_execution" +assert steps[2].step_type == "inference" +param = steps[1].tool_calls[0].arguments['param'] + +name = param.get('name', 'Not Available') +parameter_type = param.get('parameter_type', 'Not Available') +description = param.get('description', 'Not Available') + + +print(f" name {name}, parameter_type:{parameter_type}, description:{description}") + -# arbitrary_client_tool = ArbitraryClientTool(i) -# print(arbitrary_client_tool.get_tool_definition()) -# agent_config = AgentConfig( -# 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="auto", -# tool_prompt_format="json", -# max_infer_iters=4, -# ) +# ARBITRARY CLIENT TOOL +i=1 +arbitrary_client_tool = ArbitraryClientTool(i, name, parameter_type, description) +print(arbitrary_client_tool.get_tool_definition()) +agent_config = AgentConfig( + 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="auto", + tool_prompt_format="json", + max_infer_iters=4, + ) -# agent = Agent(client=client, -# agent_config=agent_config, -# client_tools=[arbitrary_client_tool] -# ) +agent = Agent(client=client, + agent_config=agent_config, + client_tools=[arbitrary_client_tool] + ) + +session_id = agent.create_session("test") +response = agent.create_turn( + messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters"}], + session_id= session_id, + ) - # session_id = agent.create_session("test") - # response = agent.create_turn( - # messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters"}], - # session_id= session_id, - # ) -print("OUTPUT:") -ev = "" -for r in EventLogger().log(response): - ev += str(r) -print(ev) +for log in EventLogger().log(response): + log.print() -data = json.loads(ev) -print(data) -# print(abbbs) -# print(response.ToolCall()) -print("END:") +print("END:") print("\n") diff --git a/experiments/tools.py b/experiments/tools.py index 5873fa8..9a4fc3d 100644 --- a/experiments/tools.py +++ b/experiments/tools.py @@ -3,17 +3,20 @@ class ArbitraryClientTool(ClientTool): - def __init__(self, n): + def __init__(self, n, name, type, description): self.n = n + self.name = name + self.type = type + self.description = description def _arbitrary_tool(self, *kwargs): return kwargs - def _generate_kwargs(self, num:int) -> dict: + def _generate_kwargs(self,num:int,name:str,parameter_type:str,description:str) -> dict: kwargs = {f"q_{n}": Parameter( - name=f"q_{n}", - parameter_type="str", - description=f"q_{n}", + name=f"{name}", + parameter_type=f"{parameter_type}", + description=f"{description}", required=True, ) for n in range(num)} @@ -26,7 +29,7 @@ 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.n) + return self._generate_kwargs(self.n,self.name,self.type,self.description) def run_impl(self, **kwargs): return self._arbitrary_tool(kwargs) From 9e9cad5c931c2b5ea3b1a56f63365beb5b1f0c88 Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Mon, 10 Mar 2025 15:57:31 +0000 Subject: [PATCH 5/9] Working example --- .../max_params_per_tool.py | 51 ++++++++++--------- experiments/tools.py | 31 +++++------ 2 files changed, 40 insertions(+), 42 deletions(-) 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 35a7a0f..cf6d029 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -5,11 +5,11 @@ from ..tools import ArbitraryClientTool, GenerateParam - client = LlamaStackClient(base_url="http://localhost:8321") # GENERATE PARAM TOOL - +i=2 + generate_param_tool = GenerateParam("param","str","This is a parameter") # print(generate_param_tool.get_tool_definition()) agent_config_param = AgentConfig( @@ -17,7 +17,7 @@ enable_session_persistence = False, 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. Create a name, parameter type, and description for the parameter +1. Create one realistic name, select a parameter type to match it, and a description. 2. Pass these into the generate_param_tool 3. Present the result clearly""", toolgroups = [], @@ -26,14 +26,14 @@ tool_prompt_format="json", max_infer_iters=4, ) -agent_param = Agent(client=client, - agent_config=agent_config_param, - client_tools=[generate_param_tool], +agent_param = Agent(client,agent_config_param, + tools=[generate_param_tool], ) - +all_params = {"name": [], "type": [], "description": []} +# for count in i: session_id = agent_param.create_session("test") response = agent_param.create_turn( - messages=[{"role":"user","content":"use the generate_param_tool and pass in a realistic and random parameter"}], + messages=[{"role":"user","content":"use the generate_param_tool and pass in a name, type, and description"}], session_id= session_id, stream=False, ) @@ -42,30 +42,31 @@ ####################################### ############# # Set Steam = False to use the steps -# for step in steps: -# print(step) -# print("\n") - -# Set Stream = True to use the EventLogger +for step in steps: + print(step) + print("\n") +# # Set Stream = True to use the EventLogger # for log in EventLogger().log(response): # log.print() -assert len(steps) == 3 -assert steps[0].step_type == "inference" -assert steps[1].step_type == "tool_execution" -assert steps[2].step_type == "inference" -param = steps[1].tool_calls[0].arguments['param'] +# assert len(steps) == 3 + +param = steps[0].api_model_response.tool_calls[0].arguments['param'] name = param.get('name', 'Not Available') -parameter_type = param.get('parameter_type', 'Not Available') +type = param.get('type', 'Not Available') description = param.get('description', 'Not Available') -print(f" name {name}, parameter_type:{parameter_type}, description:{description}") - +print(f" name {name}, type:{type}, description:{description}") +all_params["name"].append(name) +all_params["type"].append(type) +all_params["description"].append(description) # ARBITRARY CLIENT TOOL +# all_params = {"name": ["speed"], "type": ["int"], "description": ["Car speed in km/hr"]} + i=1 -arbitrary_client_tool = ArbitraryClientTool(i, name, parameter_type, description) +arbitrary_client_tool = ArbitraryClientTool(all_params) print(arbitrary_client_tool.get_tool_definition()) agent_config = AgentConfig( model="meta-llama/Llama-3.1-8B-Instruct", @@ -86,8 +87,12 @@ session_id = agent.create_session("test") response = agent.create_turn( messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters"}], - session_id= session_id, + session_id= session_id ) +# steps = response.steps +# for step in steps: +# print(step) +# print("\n") for log in EventLogger().log(response): log.print() diff --git a/experiments/tools.py b/experiments/tools.py index 9a4fc3d..6cedfef 100644 --- a/experiments/tools.py +++ b/experiments/tools.py @@ -3,24 +3,20 @@ class ArbitraryClientTool(ClientTool): - def __init__(self, n, name, type, description): - self.n = n - self.name = name - self.type = type - self.description = description + def __init__(self, all_params): + self.all_params = all_params def _arbitrary_tool(self, *kwargs): return kwargs - def _generate_kwargs(self,num:int,name:str,parameter_type:str,description:str) -> dict: - kwargs = {f"q_{n}": Parameter( - name=f"{name}", - parameter_type=f"{parameter_type}", - description=f"{description}", - required=True, - ) for n in range(num)} - - return kwargs + 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" @@ -29,15 +25,12 @@ 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.n,self.name,self.type,self.description) + return self._generate_kwargs(self.all_params) def run_impl(self, **kwargs): return self._arbitrary_tool(kwargs) - -# Tool params -# Should class GenerateParam(ClientTool): def __init__(self, name, parameter_type, description): self.name = name @@ -50,7 +43,7 @@ def _arbitrary_tool(self, *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}", + parameter_type= f"{parameter_type}", description=f"{description}", required=True, )} From 5e213e4628b017a468bf53fe05ec8ea4e0037072 Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Mon, 10 Mar 2025 16:29:47 +0000 Subject: [PATCH 6/9] Multiple generated params --- .../max_params_per_tool.py | 61 +++++++------------ 1 file changed, 23 insertions(+), 38 deletions(-) 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 cf6d029..522e2f5 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -8,18 +8,18 @@ client = LlamaStackClient(base_url="http://localhost:8321") # GENERATE PARAM TOOL -i=2 +i=20 generate_param_tool = GenerateParam("param","str","This is a parameter") -# print(generate_param_tool.get_tool_definition()) agent_config_param = AgentConfig( model="meta-llama/Llama-3.1-8B-Instruct", enable_session_persistence = False, 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. Create one realistic name, select a parameter type to match it, and a description. -2. Pass these into the generate_param_tool -3. Present the result clearly""", +1. Choose a random topic and parameter type (str/bool/int/float). +3. For the randomly selected parameter type and topic create a realistic name to match the parameter type, and a description also. +4. Pass these the name, parameter type and description in to the generate_param_tool +""", toolgroups = [], client_tools = [generate_param_tool.get_tool_definition()], tool_choice="auto", @@ -30,44 +30,33 @@ tools=[generate_param_tool], ) all_params = {"name": [], "type": [], "description": []} -# for count in i: + session_id = agent_param.create_session("test") -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, - ) +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 -####################################### -############# -# Set Steam = False to use the steps -for step in steps: - print(step) - print("\n") -# # Set Stream = True to use the EventLogger -# for log in EventLogger().log(response): -# log.print() -# assert len(steps) == 3 + steps = response.steps -param = steps[0].api_model_response.tool_calls[0].arguments['param'] + param = steps[0].api_model_response.tool_calls[0].arguments['param'] -name = param.get('name', 'Not Available') -type = param.get('type', 'Not Available') -description = param.get('description', 'Not Available') - + name = param.get('name', 'Not Available') + type = param.get('type', 'Not Available') + description = param.get('description', 'Not Available') + -print(f" name {name}, type:{type}, description:{description}") -all_params["name"].append(name) -all_params["type"].append(type) -all_params["description"].append(description) + print(f" name {name}, type:{type}, description:{description}") + all_params["name"].append(name) + all_params["type"].append(type) + all_params["description"].append(description) # ARBITRARY CLIENT TOOL -# all_params = {"name": ["speed"], "type": ["int"], "description": ["Car speed in km/hr"]} - i=1 arbitrary_client_tool = ArbitraryClientTool(all_params) -print(arbitrary_client_tool.get_tool_definition()) + agent_config = AgentConfig( model="meta-llama/Llama-3.1-8B-Instruct", enable_session_persistence = False, @@ -89,10 +78,6 @@ messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters"}], session_id= session_id ) -# steps = response.steps -# for step in steps: -# print(step) -# print("\n") for log in EventLogger().log(response): log.print() From 6d61c48fe9341ed9e604f2d7ba16ede2926d9e67 Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Thu, 20 Mar 2025 17:13:58 +0000 Subject: [PATCH 7/9] notebook results for single tool call --- .../max_param_analysis.ipynb | 1358 +++++++++++++++++ .../max_params_per_tool.py | 140 +- experiments/tools.py | 13 + 3 files changed, 1444 insertions(+), 67 deletions(-) create mode 100644 experiments/max_params_per_tool/max_param_analysis.ipynb 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..07a550f --- /dev/null +++ b/experiments/max_params_per_tool/max_param_analysis.ipynb @@ -0,0 +1,1358 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of the Max params" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "llama-stack-client, version 0.1.7\n" + ] + } + ], + "source": [ + "# !llama-stack-client --version" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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": "code", + "execution_count": 3, + "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": [ + "get_params = get_params(50)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting test: ['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" + ] + } + ], + "source": [ + "print(f\"Starting test: {get_params['name']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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(get_params['name'])):\n", + " if get_params['name'][i] in seen_names:\n", + " # Mark the index for removal if name is duplicated\n", + " print(f\"Duplicate name found: {get_params['name'][i]}\")\n", + " indices_to_remove.append(i)\n", + " else:\n", + " # Otherwise, add to the set of seen names\n", + " seen_names.add(get_params['name'][i])\n", + "\n", + "# Remove the entries that have duplicates in 'name'\n", + "get_params['name'] = [get_params['name'][i] for i in range(len(get_params['name'])) if i not in indices_to_remove]\n", + "get_params['type'] = [get_params['type'][i] for i in range(len(get_params['type'])) if i not in indices_to_remove]\n", + "get_params['description'] = [get_params['description'][i] for i in range(len(get_params['description'])) if i not in indices_to_remove]\n", + "\n", + "# Output the cleaned get_params\n", + "print(\"Data cleaned (duplicates removed): \\n\")\n", + "for param in get_params:\n", + " print(param, get_params[param])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "42\n" + ] + } + ], + "source": [ + "print(len(get_params['name']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "Parameters used: \n", + "\n", + "parking_sonar ultrasonic\n", + "Parameter checks completed.\n", + "2\n", + "Parameters used: \n", + "\n", + "blind_spot_monitoring radar\n", + "rear_view_camera backup camera\n", + "Parameter checks completed.\n", + "3\n", + "Parameters used: \n", + "\n", + "speed_limit 120.0\n", + "gear_ratio 3.5\n", + "rear_view_camera backup camera\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "4\n", + "Parameters used: \n", + "\n", + "voice_command text_to_speech\n", + "speed 50.0\n", + "remote_start key_fob\n", + "direction forward\n", + "Parameter checks completed.\n", + "5\n", + "Parameters used: \n", + "\n", + "fuel_level 0.5\n", + "voice_command Siri\n", + "automatic_emergency_braking ABS\n", + "temperature 25.0\n", + "suspension_type MacPherson\n", + "Parameter checks completed.\n", + "6\n", + "Parameters used: \n", + "\n", + "voice_command Siri\n", + "location New York\n", + "keyless_entry Biometric\n", + "electronic_stability_control ESC\n", + "altitude 1000.0\n", + "speed 60.0\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter checks completed.\n", + "7\n", + "Parameters used: \n", + "\n", + "engine_size 3.5\n", + "seat_type leather\n", + "gear_ratio 4.2\n", + "direction forward\n", + "electronic_stability_control ESC\n", + "remote_start keyless\n", + "fuel_efficiency 25.0\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "8\n", + "Parameters used: \n", + "\n", + "transmission_type automatic\n", + "temperature 25.0\n", + "lane_departure_warning active\n", + "suspension_type hydraulic\n", + "humidity 60.0\n", + "parking_sonar ultrasonic\n", + "360_degree_camera high_definition\n", + "horsepower 200.0\n", + "Parameter 'humidity' 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", + "9\n", + "Parameters used: \n", + "\n", + "voice_command Siri\n", + "smartphone_app Google Maps\n", + "speed_limit 60.0\n", + "engine_size 2.0L\n", + "airbag_type Dual Airbags\n", + "brake_type Disc Brakes\n", + "steering_type Power Steering\n", + "blind_spot_monitor Blind Spot Monitoring System\n", + "fuel_efficiency 25.0\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 'str'.\n", + "Parameter checks completed.\n", + "10\n", + "Parameters used: \n", + "\n", + "parking_sensors ultrasonic\n", + "driver_monitoring camera\n", + "location city\n", + "blind_spot_monitoring mirror\n", + "keyless_entry fingerprint\n", + "distance 100.0\n", + "horsepower 200.0\n", + "adaptive_cruise_control radar\n", + "pressure high\n", + "lane_departure_warning alert\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "11\n", + "Parameters used: \n", + "\n", + "push_start_button button\n", + "steering_type electric\n", + "temperature 25.0\n", + "fuel_efficiency 10.0\n", + "360_degree_camera panoramic\n", + "brake_type disc\n", + "time morning\n", + "traffic_sign_recognition AI-powered\n", + "electronic_stability_control advanced\n", + "altitude 1000.0\n", + "direction north\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter checks completed.\n", + "12\n", + "Parameters used: \n", + "\n", + "humidity high\n", + "remote_start keyless\n", + "navigation_system GPS\n", + "push_start_button button\n", + "speed_limit 60.0\n", + "torque 200.0\n", + "adaptive_cruise_control lane_centering\n", + "electronic_stability_control ESC\n", + "pressure high\n", + "brake_type disc\n", + "transmission_type automatic\n", + "speed 120.0\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "13\n", + "Parameters used: \n", + "\n", + "voice_command Siri\n", + "blind_spot_monitoring Rearview Camera\n", + "driver_monitoring Eye Tracking\n", + "anti_lock_brake_system ABS\n", + "seat_type Heated Seats\n", + "360_degree_camera Panoramic View\n", + "traffic_sign_recognition AI-powered Signs\n", + "speed_limit 65.0\n", + "horsepower 300.0\n", + "pressure High Pressure\n", + "fuel_efficiency Hybrid Engine\n", + "humidity 60.0\n", + "push_start_button Touchscreen Button\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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "14\n", + "Parameters used: \n", + "\n", + "temperature 25.0\n", + "transmission_type automatic\n", + "remote_start True\n", + "push_start_button False\n", + "horsepower 200.0\n", + "anti_lock_brake_system ABS\n", + "humidity 60.0\n", + "fuel_level 0.75\n", + "torque 300.0\n", + "keyless_entry keyfob\n", + "automatic_emergency_braking True\n", + "driver_monitoring camera\n", + "electronic_stability_control ESC\n", + "steering_type power\n", + "Parameter 'remote_start' has an invalid type. Expected 'str', but got 'bool'.\n", + "Parameter 'push_start_button' has an invalid type. Expected 'str', but got 'bool'.\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 'automatic_emergency_braking' has an invalid type. Expected 'str', but got 'bool'.\n", + "Parameter checks completed.\n", + "15\n", + "Parameters used: \n", + "\n", + "push_start_button automatic\n", + "pressure high\n", + "blind_spot_monitoring lane_departure_warning\n", + "remote_start keyless_entry\n", + "distance 500.0\n", + "traffic_sign_recognition speed_limit_signs\n", + "direction north\n", + "engine_size v8\n", + "anti_lock_brake_system electronic_control\n", + "smartphone_app android\n", + "rear_view_camera backup_camera\n", + "humidity 60.0\n", + "temperature 25.0\n", + "blind_spot_monitor side_blind_spot_warning\n", + "electronic_stability_control dynamic_stability_control\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "16\n", + "Parameters used: \n", + "\n", + "suspension_type electronic\n", + "voice_command natural_language\n", + "gear_ratio 4.5\n", + "traffic_sign_recognition computer_vision\n", + "transmission_type automatic\n", + "lane_departure_warning camera_based\n", + "navigation_system GPS\n", + "brake_type regenerative_braking\n", + "pressure high\n", + "fuel_level 0.75\n", + "keyless_entry rfid\n", + "push_start_button touchscreen\n", + "temperature 25.0\n", + "seat_type heated\n", + "engine_size 2.5\n", + "360_degree_camera ultrawide\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "17\n", + "Parameters used: \n", + "\n", + "humidity 0.0\n", + "speed_limit 100.0\n", + "smartphone_app Android\n", + "distance 500.0\n", + "location New York\n", + "blind_spot_monitor Rear View Camera\n", + "lane_centering Lane Departure Warning\n", + "suspension_type MacPherson Strut\n", + "remote_start Keyless Entry\n", + "airbag_type Dual Airbags\n", + "speed 60.0\n", + "seat_type Heated Seats\n", + "parking_sonar 360-Degree Parking Sensors\n", + "direction North\n", + "parking_sensors Ultrasonic Sensors\n", + "push_start_button Start Button on Steering Wheel\n", + "steering_type Electric Power Steering\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", + "18\n", + "Parameters used: \n", + "\n", + "blind_spot_monitoring Lane Departure Warning System\n", + "driver_monitoring Driver Fatigue Monitoring System\n", + "360_degree_camera Panoramic Camera\n", + "parking_sonar Ultrasonic Parking Sensor\n", + "navigation_system GPS Navigation\n", + "speed_limit 65.0\n", + "time Daytime\n", + "voice_command Voice Assistant\n", + "altitude 1000.0\n", + "brake_type Regenerative Braking System\n", + "traffic_sign_recognition Computer Vision-Based Recognition\n", + "horsepower 200.0\n", + "pressure High Pressure\n", + "temperature 25.0\n", + "rear_view_camera Wide-Angle Rear View Camera\n", + "seat_type Heated Seats\n", + "speed 60.0\n", + "transmission_type Automatic Transmission\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "19\n", + "Parameters used: \n", + "\n", + "fuel_level 0.5\n", + "speed_limit 120.0\n", + "torque 200.0\n", + "engine_size 2.0\n", + "airbag_type Dual Airbags\n", + "lane_centering Lane Departure Warning\n", + "parking_sonar Front and Rear Parking Sensors\n", + "location New York\n", + "brake_type Disc Brakes\n", + "seat_type Heated Seats\n", + "keyless_entry Keyless Entry with Push Start\n", + "360_degree_camera 4 Camera System\n", + "rear_view_camera Rear View Camera\n", + "pressure High Pressure\n", + "fuel_efficiency 25.0\n", + "navigation_system GPS Navigation\n", + "blind_spot_monitoring Blind Spot Monitoring\n", + "driver_monitoring Driver Attention Monitor\n", + "steering_type Power Steering\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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "20\n", + "Error with the tool\n", + "21\n", + "Parameters used: \n", + "\n", + "seat_type leather\n", + "time morning\n", + "keyless_entry fingerprint\n", + "adaptive_cruise_control lane_centering\n", + "horsepower 300.0\n", + "torque 400.0\n", + "anti_lock_brake_system electronic\n", + "lane_centering camera_based\n", + "direction north\n", + "smartphone_app android\n", + "driver_monitoring eye_tracking\n", + "lane_departure_warning audible_alert\n", + "rear_view_camera wide_angle\n", + "push_start_button paddle_shift\n", + "suspension_type adaptive_damping\n", + "navigation_system satellite_based\n", + "remote_start key_fob\n", + "parking_sonar ultrasonic\n", + "gear_ratio 4.5\n", + "blind_spot_monitoring mirror_based\n", + "temperature 22.0\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "22\n", + "Parameters used: \n", + "\n", + "parking_sensors ultrasonic\n", + "smartphone_app android\n", + "electronic_stability_control ESC\n", + "parking_sonar sonar_system\n", + "temperature 25.0\n", + "altitude 1000.0\n", + "suspension_type coil_over_shock\n", + "pressure high\n", + "automatic_emergency_braking AEB\n", + "360_degree_camera panoramic_camera\n", + "push_start_button keyless_entry\n", + "seat_type heated_seat\n", + "speed 60.0\n", + "remote_start key_fob\n", + "horsepower 300.0\n", + "distance 500.0\n", + "humidity 50.0\n", + "steering_type electric_power_steering\n", + "lane_centering lane_departure_warning\n", + "adaptive_cruise_control ACC\n", + "gear_ratio 4.5\n", + "torque 400.0\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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", + "23\n", + "Parameters used: \n", + "\n", + "distance 10\n", + "keyless_entry fingerprint\n", + "fuel_level 75\n", + "humidity 60\n", + "navigation_system GPS\n", + "brake_type disc\n", + "location [37.7749, -122.4194]\n", + "blind_spot_monitor camera\n", + "automatic_emergency_braking yes\n", + "electronic_stability_control yes\n", + "traffic_sign_recognition AI\n", + "airbag_type dual\n", + "blind_spot_monitoring radar\n", + "lane_departure_warning audio\n", + "push_start_button keyless\n", + "360_degree_camera yes\n", + "altitude 1000\n", + "gear_ratio 4.5\n", + "smartphone_app Android\n", + "engine_size 2.0L\n", + "horsepower 150\n", + "remote_start yes\n", + "pressure high\n", + "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 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "24\n", + "Parameters used: \n", + "\n", + "airbag_type Dual Airbag\n", + "360_degree_camera High-Definition Camera\n", + "automatic_emergency_braking Advanced Emergency Braking System\n", + "speed 120.0\n", + "smartphone_app SmartDrive App\n", + "engine_size 2.0L Turbocharged Engine\n", + "parking_sonar Multi-Angle Parking Sonar\n", + "voice_command Voice Command System\n", + "speed_limit 65.0\n", + "fuel_efficiency Up to 30 MPG\n", + "suspension_type Adaptive Suspension\n", + "time Morning\n", + "traffic_sign_recognition Advanced Traffic Sign Recognition\n", + "driver_monitoring Driver Attention Monitoring\n", + "temperature 75.0\n", + "blind_spot_monitoring Blind Spot Information System\n", + "transmission_type 8-Speed Automatic Transmission\n", + "brake_type Regenerative Braking System\n", + "electronic_stability_control Electronic Stability Control System\n", + "pressure High Pressure\n", + "navigation_system GPS Navigation System\n", + "direction Northbound\n", + "gear_ratio 3.5\n", + "location City Center\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "25\n", + "Parameters used: \n", + "\n", + "time morning\n", + "brake_type disc brake\n", + "speed 60.0\n", + "gear_ratio 3.5\n", + "transmission_type automatic\n", + "seat_type leather\n", + "distance 100.0\n", + "pressure high\n", + "keyless_entry push button start\n", + "direction north\n", + "speed_limit 70.0\n", + "lane_centering camera based\n", + "adaptive_cruise_control radar based\n", + "suspension_type macpherson strut\n", + "lane_departure_warning visual alert\n", + "electronic_stability_control ESC\n", + "rear_view_camera backup camera\n", + "temperature 25.0\n", + "airbag_type dual airbag\n", + "parking_sonar ultrasonic sensor\n", + "location city center\n", + "automatic_emergency_braking autonomous emergency braking\n", + "fuel_level 0.75\n", + "navigation_system GPS navigation\n", + "360_degree_camera panoramic camera\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "26\n", + "Parameters used: \n", + "\n", + "remote_start keyless_entry\n", + "altitude high\n", + "humidity low\n", + "electronic_stability_control adaptive_cruise_control\n", + "rear_view_camera blind_spot_monitoring\n", + "location city\n", + "navigation_system GPS\n", + "temperature hot\n", + "engine_size large\n", + "speed fast\n", + "smartphone_app Android\n", + "gear_ratio automatic\n", + "fuel_level full\n", + "horsepower high\n", + "lane_departure_warning active\n", + "steering_type electric\n", + "time day\n", + "speed_limit 60mph\n", + "keyless_entry fingerprint\n", + "adaptive_cruise_control lane_centering\n", + "blind_spot_monitoring rear_view\n", + "torque high\n", + "seat_type heated\n", + "pressure high\n", + "anti_lock_brake_system ABS\n", + "airbag_type dual\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'speed' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter checks completed.\n", + "27\n", + "Parameters used: \n", + "\n", + "lane_departure_warning Lane Departure Warning System\n", + "airbag_type Dual Airbag\n", + "distance 100.0\n", + "360_degree_camera Panoramic Camera\n", + "transmission_type Automatic Transmission\n", + "pressure High Pressure\n", + "traffic_sign_recognition Traffic Sign Recognition System\n", + "push_start_button Push Start Button\n", + "blind_spot_monitor Blind Spot Monitor\n", + "anti_lock_brake_system Anti-Lock Brake System\n", + "horsepower 200.0\n", + "humidity 60.0\n", + "engine_size 2.0L\n", + "parking_sensors Parking Sensors\n", + "temperature 25.0\n", + "adaptive_cruise_control Adaptive Cruise Control\n", + "speed_limit 120.0\n", + "gear_ratio 4.5\n", + "electronic_stability_control Electronic Stability Control\n", + "direction North\n", + "steering_type Power Steering\n", + "torque 300.0\n", + "driver_monitoring Driver Monitoring System\n", + "blind_spot_monitoring Blind Spot Monitoring System\n", + "location New York\n", + "altitude 1000.0\n", + "seat_type Heated Seat\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter checks completed.\n", + "28\n", + "Parameters used: \n", + "\n", + "anti_lock_brake_system ABS\n", + "voice_command Siri\n", + "parking_sensors Ultrasonic\n", + "gear_ratio 4.2\n", + "parking_sonar Radar\n", + "pressure High\n", + "lane_centering Laser\n", + "horsepower 300.0\n", + "360_degree_camera Panoramic\n", + "speed 120.0\n", + "brake_type Disc\n", + "blind_spot_monitoring Camera\n", + "speed_limit 65.0\n", + "airbag_type Dual\n", + "remote_start Keyless\n", + "blind_spot_monitor Ultrasonic\n", + "driver_monitoring Eye-tracking\n", + "time Morning\n", + "humidity 60.0\n", + "lane_departure_warning Laser\n", + "adaptive_cruise_control Radar\n", + "automatic_emergency_braking Camera\n", + "temperature 25.0\n", + "torque 400.0\n", + "suspension_type MacPherson\n", + "smartphone_app Android\n", + "location City\n", + "distance 100.0\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "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 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "29\n", + "Parameters used: \n", + "\n", + "navigation_system GPS\n", + "distance 100.0\n", + "airbag_type Dual Airbags\n", + "torque 200.0\n", + "temperature 25.0\n", + "location New York\n", + "brake_type Disc Brakes\n", + "lane_departure_warning Active Lane Departure Warning\n", + "360_degree_camera Panoramic View Camera\n", + "altitude 1000.0\n", + "seat_type Heated Seats\n", + "rear_view_camera Rearview Camera\n", + "lane_centering Lane Centering System\n", + "automatic_emergency_braking Automatic Emergency Braking\n", + "speed 60.0\n", + "parking_sonar Parking Sonar System\n", + "remote_start Remote Start System\n", + "smartphone_app Smartphone App Connectivity\n", + "fuel_efficiency High Fuel Efficiency\n", + "electronic_stability_control Electronic Stability Control\n", + "driver_monitoring Driver Monitoring System\n", + "time 10:00 AM\n", + "gear_ratio 3.5\n", + "pressure High Pressure\n", + "direction North\n", + "anti_lock_brake_system Anti-Lock Braking System\n", + "blind_spot_monitoring Blind Spot Monitoring System\n", + "speed_limit 65.0\n", + "horsepower 300.0\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 checks completed.\n", + "30\n", + "Parameters used: \n", + "\n", + "torque string\n", + "seat_type integer\n", + "360_degree_camera boolean\n", + "speed_limit float\n", + "adaptive_cruise_control array\n", + "push_start_button null\n", + "anti_lock_brake_system object\n", + "suspension_type string\n", + "blind_spot_monitoring number\n", + "automatic_emergency_braking integer\n", + "voice_command boolean\n", + "location string\n", + "distance array\n", + "gear_ratio object\n", + "pressure null\n", + "temperature float\n", + "fuel_level string\n", + "rear_view_camera boolean\n", + "driver_monitoring number\n", + "keyless_entry integer\n", + "brake_type object\n", + "horsepower array\n", + "navigation_system string\n", + "engine_size float\n", + "airbag_type null\n", + "humidity float\n", + "time string\n", + "electronic_stability_control boolean\n", + "remote_start integer\n", + "lane_departure_warning object\n", + "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter checks completed.\n", + "31\n", + "Parameters used: \n", + "\n", + "blind_spot_monitoring Lane Departure Warning System\n", + "brake_type Disc Brake\n", + "direction Forward\n", + "horsepower 300.0\n", + "push_start_button Push Button Start\n", + "navigation_system GPS Navigation\n", + "gear_ratio 4.5\n", + "location City\n", + "adaptive_cruise_control Adaptive Cruise Control\n", + "suspension_type MacPherson Strut\n", + "airbag_type Dual Airbag\n", + "360_degree_camera 360 Degree Camera\n", + "voice_command Voice Command System\n", + "fuel_level 75.0\n", + "seat_type Heated Seat\n", + "distance 100.0\n", + "anti_lock_brake_system Anti-Lock Brake System\n", + "engine_size 2.0\n", + "remote_start Remote Start System\n", + "smartphone_app Smartphone App\n", + "parking_sensors Parking Sensors\n", + "transmission_type Automatic Transmission\n", + "blind_spot_monitor Blind Spot Monitor\n", + "speed_limit 60.0\n", + "automatic_emergency_braking Automatic Emergency Braking\n", + "fuel_efficiency 25.0\n", + "driver_monitoring Driver Monitoring System\n", + "humidity 50.0\n", + "torque 250.0\n", + "lane_departure_warning Lane Departure Warning\n", + "time 10:00 AM\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 '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 'str'.\n", + "Parameter checks completed.\n", + "32\n", + "Parameters used: \n", + "\n", + "360_degree_camera Panoramic Camera\n", + "driver_monitoring Advanced Driver Monitoring System\n", + "fuel_efficiency Hybrid Fuel Efficiency\n", + "torque Electric Torque\n", + "steering_type Steer-by-Wire Steering\n", + "parking_sonar Multi-Mode Parking Sonar\n", + "altitude 1000.0\n", + "push_start_button Keyless Push Start Button\n", + "lane_departure_warning Lane Departure Warning System\n", + "rear_view_camera Wide-Angle Rear View Camera\n", + "remote_start Remote Engine Start System\n", + "transmission_type Automatic Transmission\n", + "speed 120.0\n", + "smartphone_app Smartphone App Connectivity\n", + "automatic_emergency_braking Advanced Automatic Emergency Braking\n", + "horsepower 300.0\n", + "lane_centering Lane Centering Assist\n", + "seat_type Heated and Cooled Seats\n", + "direction North\n", + "keyless_entry Keyless Entry System\n", + "navigation_system GPS Navigation System\n", + "traffic_sign_recognition Traffic Sign Recognition System\n", + "pressure High Pressure\n", + "fuel_level 75.0\n", + "voice_command Voice Command System\n", + "temperature 25.0\n", + "adaptive_cruise_control Adaptive Cruise Control System\n", + "location New York City\n", + "electronic_stability_control Electronic Stability Control System\n", + "blind_spot_monitoring Blind Spot Monitoring System\n", + "speed_limit 65.0\n", + "gear_ratio 4.5\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", + "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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "33\n", + "Parameters used: \n", + "\n", + "fuel_level 0.5\n", + "parking_sonar ultrasonic\n", + "adaptive_cruise_control lane_centering\n", + "fuel_efficiency gasoline\n", + "parking_sensors rear_view_camera\n", + "altitude 1000.0\n", + "rear_view_camera wide_angle\n", + "lane_departure_warning audible_alert\n", + "steering_type electric_power_steering\n", + "transmission_type automatic\n", + "remote_start keyless_entry\n", + "speed_limit 60.0\n", + "brake_type disc_brakes\n", + "push_start_button smartphone_app\n", + "smartphone_app android\n", + "blind_spot_monitoring visual_alert\n", + "time morning\n", + "humidity 0.7\n", + "lane_centering adaptive_lane_centering\n", + "pressure high_pressure\n", + "distance 500.0\n", + "navigation_system gps_navigation\n", + "automatic_emergency_braking full_auto_braking\n", + "voice_command natural_language_processing\n", + "driver_monitoring eye_tracking\n", + "360_degree_camera panoramic_view\n", + "direction northbound\n", + "seat_type heated_seat\n", + "keyless_entry proximity_sensor\n", + "electronic_stability_control electronic_stability_program\n", + "traffic_sign_recognition machine_learning_based\n", + "horsepower 200.0\n", + "location city_center\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "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 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "34\n", + "Parameters used: \n", + "\n", + "blind_spot_monitoring Lane Departure Warning System\n", + "360_degree_camera Panoramic Camera\n", + "altitude 1000.0\n", + "time 12:00 PM\n", + "automatic_emergency_braking Autonomous Emergency Braking\n", + "electronic_stability_control Electronic Stability Control\n", + "temperature 25.0\n", + "speed 60.0\n", + "pressure High Pressure\n", + "navigation_system GPS Navigation\n", + "blind_spot_monitor Blind Spot Monitor\n", + "adaptive_cruise_control Adaptive Cruise Control\n", + "fuel_level 75.0\n", + "transmission_type Automatic Transmission\n", + "lane_centering Lane Centering System\n", + "parking_sonar Parking Sonar System\n", + "lane_departure_warning Lane Departure Warning System\n", + "engine_size 2.0L Engine\n", + "keyless_entry Keyless Entry System\n", + "humidity 60.0\n", + "distance 100.0\n", + "traffic_sign_recognition Traffic Sign Recognition System\n", + "rear_view_camera Rear View Camera\n", + "gear_ratio 3.5\n", + "remote_start Remote Start System\n", + "horsepower 200.0\n", + "location New York City\n", + "suspension_type MacPherson Strut Suspension\n", + "parking_sensors Parking Sensors System\n", + "voice_command Voice Command System\n", + "push_start_button Push Start Button System\n", + "airbag_type Dual Airbag System\n", + "fuel_efficiency 25.0\n", + "torque 250.0\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'humidity' 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", + "35\n", + "Error with the tool\n", + "36\n", + "Parameters used: \n", + "\n", + "seat_type leather\n", + "altitude 1000.0\n", + "automatic_emergency_braking yes\n", + "lane_centering active\n", + "torque 200.0\n", + "lane_departure_warning audible\n", + "smartphone_app android\n", + "transmission_type automatic\n", + "keyless_entry fingerprint\n", + "adaptive_cruise_control speed\n", + "blind_spot_monitoring camera\n", + "voice_command natural_language\n", + "gear_ratio 4.0\n", + "fuel_efficiency high\n", + "electronic_stability_control active\n", + "location city\n", + "rear_view_camera wide_angle\n", + "direction north\n", + "push_start_button button\n", + "airbag_type dual\n", + "anti_lock_brake_system ABS\n", + "brake_type disc\n", + "navigation_system GPS\n", + "horsepower 300.0\n", + "humidity 60.0\n", + "speed_limit 65.0\n", + "traffic_sign_recognition camera\n", + "parking_sonar ultrasonic\n", + "blind_spot_monitor camera\n", + "time morning\n", + "distance 50.0\n", + "360_degree_camera panoramic\n", + "pressure high\n", + "driver_monitoring eye_tracking\n", + "fuel_level 75.0\n", + "engine_size 2.0\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\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 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "37\n", + "Parameters used: \n", + "\n", + "airbag_type Dual Airbag\n", + "anti_lock_brake_system Electronic Brakeforce Distribution (EBD)\n", + "direction Forward\n", + "voice_command Voice Command System\n", + "smartphone_app Smartphone App Integration\n", + "rear_view_camera Rear View Camera\n", + "fuel_level Full\n", + "navigation_system GPS Navigation\n", + "parking_sensors Parking Sensors\n", + "steering_type Power Steering\n", + "blind_spot_monitor Blind Spot Monitor\n", + "speed 120.0\n", + "lane_departure_warning Lane Departure Warning System\n", + "torque 300.0\n", + "location New York\n", + "transmission_type Automatic Transmission\n", + "lane_centering Lane Centering System\n", + "blind_spot_monitoring Blind Spot Monitoring System\n", + "traffic_sign_recognition Traffic Sign Recognition System\n", + "fuel_efficiency High Fuel Efficiency\n", + "pressure High Pressure\n", + "speed_limit 65.0\n", + "brake_type Disc Brake\n", + "push_start_button Push Start Button\n", + "horsepower 200.0\n", + "temperature 25.0\n", + "suspension_type MacPherson Strut Suspension\n", + "seat_type Heated Seats\n", + "time 10:00 AM\n", + "electronic_stability_control Electronic Stability Control (ESC)\n", + "automatic_emergency_braking Automatic Emergency Braking System\n", + "altitude 1000.0\n", + "parking_sonar Parking Sonar System\n", + "adaptive_cruise_control Adaptive Cruise Control System\n", + "remote_start Remote Start System\n", + "humidity 60.0\n", + "driver_monitoring Driver Monitoring System\n", + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'str'.\n", + "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "Parameter checks completed.\n", + "38\n", + "Error with the tool\n", + "39\n", + "Parameters used: \n", + "\n", + "brake_type disc brake\n", + "push_start_button keyless start button\n", + "360_degree_camera high-definition camera\n", + "keyless_entry fingerprint recognition\n", + "lane_centering electronic power steering\n", + "parking_sonar ultrasonic sensors\n", + "suspension_type adaptive suspension\n", + "driver_monitoring facial recognition\n", + "engine_size 2.0L\n", + "adaptive_cruise_control radar-based system\n", + "transmission_type automatic transmission\n", + "torque 300 Nm\n", + "automatic_emergency_braking collision avoidance system\n", + "electronic_stability_control electronic stability program\n", + "location New York City\n", + "navigation_system GPS navigation\n", + "fuel_level full tank\n", + "remote_start smartphone app\n", + "steering_type power steering\n", + "parking_sensors ultrasonic sensors\n", + "seat_type heated seats\n", + "horsepower 200 HP\n", + "temperature 20°C\n", + "lane_departure_warning visual alert system\n", + "voice_command natural language processing\n", + "airbag_type multi-stage airbags\n", + "humidity 60%\n", + "smartphone_app Android app\n", + "gear_ratio 6-speed transmission\n", + "blind_spot_monitor camera-based system\n", + "speed_limit 65 mph\n", + "time 10:00 AM\n", + "rear_view_camera high-definition camera\n", + "pressure normal pressure\n", + "distance 100 miles\n", + "fuel_efficiency 25 mpg\n", + "blind_spot_monitoring camera-based system\n", + "direction northbound\n", + "altitude 500 ft\n", + "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'humidity' has an invalid type. Expected 'int', 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 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\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(get_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': [get_params['name'][idx] for idx in random_indices],\n", + " 'type': [get_params['type'][idx] for idx in random_indices],\n", + " 'description': [get_params['description'][idx] for idx in random_indices]\n", + " }\n", + " print(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": "code", + "execution_count": 20, + "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": "code", + "execution_count": 18, + "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" + ] + } + ], + "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 522e2f5..2be5bc5 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -3,84 +3,90 @@ from llama_stack_client.types.agent_create_params import AgentConfig from llama_stack_client import LlamaStackClient from ..tools import ArbitraryClientTool, GenerateParam +import json +import ast client = LlamaStackClient(base_url="http://localhost:8321") # GENERATE PARAM TOOL -i=20 +def get_params(i): + generate_param_tool = GenerateParam("param","str","This is a parameter") -generate_param_tool = GenerateParam("param","str","This is a parameter") -agent_config_param = AgentConfig( -model="meta-llama/Llama-3.1-8B-Instruct", -enable_session_persistence = False, -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. Choose a random topic and parameter type (str/bool/int/float). -3. For the randomly selected parameter type and topic create a realistic name to match the parameter type, and a description also. -4. Pass these the name, parameter type and description in to the generate_param_tool -""", -toolgroups = [], -client_tools = [generate_param_tool.get_tool_definition()], -tool_choice="auto", -tool_prompt_format="json", -max_infer_iters=4, -) -agent_param = Agent(client,agent_config_param, - 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, + agent_param = Agent(client, + model="meta-llama/Llama-3.1-8B-Instruct", + enable_session_persistence = False, + 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": []} - steps = response.steps - - param = steps[0].api_model_response.tool_calls[0].arguments['param'] - - name = param.get('name', 'Not Available') - type = param.get('type', 'Not Available') - description = param.get('description', 'Not Available') - + 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, + ) + # for log in EventLogger().log(response): + # log.print() + steps = response.steps + # for step in steps: + # print(step) + 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') - print(f" name {name}, type:{type}, description:{description}") - all_params["name"].append(name) - all_params["type"].append(type) - all_params["description"].append(description) + 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 -# ARBITRARY CLIENT TOOL -i=1 -arbitrary_client_tool = ArbitraryClientTool(all_params) +def test_abitrary_client_tool(all_params): + arbitrary_client_tool = ArbitraryClientTool(all_params) -agent_config = AgentConfig( - 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="auto", - tool_prompt_format="json", - max_infer_iters=4, - ) - -agent = Agent(client=client, - agent_config=agent_config, - client_tools=[arbitrary_client_tool] - ) + agent = Agent(client, + model="meta-llama/Llama-3.1-8B-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.", + tools=[arbitrary_client_tool] + ) -session_id = agent.create_session("test") -response = agent.create_turn( - messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters"}], - session_id= session_id - ) + session_id = agent.create_session("test") + response = agent.create_turn( + messages=[{"role":"user","content":"use the arbitrary_client_tool and pass in parameters according to their type"}], + session_id= session_id, + stream=False, + ) -for log in EventLogger().log(response): - log.print() + # for log in EventLogger().log(response): + # log.print() + return response -print("END:") -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 6cedfef..a226f15 100644 --- a/experiments/tools.py +++ b/experiments/tools.py @@ -3,6 +3,11 @@ class ArbitraryClientTool(ClientTool): + """AbitraryClientTool is a tool that returns the parameters passed to it. + + :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 @@ -32,6 +37,14 @@ def run_impl(self, **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 From 4188d937192c57c3c343b7ccae0ce1dbb8f60b3f Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Mon, 24 Mar 2025 18:07:37 +0000 Subject: [PATCH 8/9] results of max_param analysis --- .../ollama_3_1_8B_temp_high.csv | 39 + .../ollama_3_1_8B_temp_mid.csv | 39 + .../ollama_3_2_3B_temp_high.csv | 40 + .../ollama_3_2_3B_temp_low.csv | 40 + .../ollama_3_2_3B_temp_mid.csv | 40 + .../max_param_analysis.ipynb | 1653 +++++++---------- .../max_params_per_tool.py | 35 +- experiments/tools.py | 2 +- 8 files changed, 920 insertions(+), 968 deletions(-) create mode 100644 experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_high.csv create mode 100644 experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_1_8B_temp_mid.csv create mode 100644 experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_high.csv create mode 100644 experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_low.csv create mode 100644 experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_mid.csv 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_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 index 07a550f..75d1b27 100644 --- a/experiments/max_params_per_tool/max_param_analysis.ipynb +++ b/experiments/max_params_per_tool/max_param_analysis.ipynb @@ -7,30 +7,6 @@ "# Analysis of the Max params" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "llama-stack-client, version 0.1.7\n" - ] - } - ], - "source": [ - "# !llama-stack-client --version" - ] - }, { "cell_type": "code", "execution_count": 2, @@ -112,13 +88,6 @@ "get_params = get_params(50)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 4, @@ -200,1000 +169,734 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "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": [ - "1\n", - "Parameters used: \n", - "\n", - "parking_sonar ultrasonic\n", - "Parameter checks completed.\n", - "2\n", - "Parameters used: \n", - "\n", - "blind_spot_monitoring radar\n", - "rear_view_camera backup camera\n", - "Parameter checks completed.\n", - "3\n", - "Parameters used: \n", - "\n", - "speed_limit 120.0\n", - "gear_ratio 3.5\n", - "rear_view_camera backup camera\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "4\n", - "Parameters used: \n", - "\n", - "voice_command text_to_speech\n", - "speed 50.0\n", - "remote_start key_fob\n", - "direction forward\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", - "5\n", - "Parameters used: \n", - "\n", - "fuel_level 0.5\n", - "voice_command Siri\n", - "automatic_emergency_braking ABS\n", - "temperature 25.0\n", - "suspension_type MacPherson\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 checks completed.\n", - "6\n", - "Parameters used: \n", - "\n", - "voice_command Siri\n", - "location New York\n", - "keyless_entry Biometric\n", - "electronic_stability_control ESC\n", - "altitude 1000.0\n", - "speed 60.0\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\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 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter checks completed.\n", - "7\n", - "Parameters used: \n", - "\n", - "engine_size 3.5\n", - "seat_type leather\n", - "gear_ratio 4.2\n", - "direction forward\n", - "electronic_stability_control ESC\n", - "remote_start keyless\n", - "fuel_efficiency 25.0\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'float'.\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", - "8\n", - "Parameters used: \n", - "\n", - "transmission_type automatic\n", - "temperature 25.0\n", - "lane_departure_warning active\n", - "suspension_type hydraulic\n", - "humidity 60.0\n", - "parking_sonar ultrasonic\n", - "360_degree_camera high_definition\n", - "horsepower 200.0\n", - "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\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 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", "Parameter checks completed.\n", - "9\n", - "Parameters used: \n", - "\n", - "voice_command Siri\n", - "smartphone_app Google Maps\n", - "speed_limit 60.0\n", - "engine_size 2.0L\n", - "airbag_type Dual Airbags\n", - "brake_type Disc Brakes\n", - "steering_type Power Steering\n", - "blind_spot_monitor Blind Spot Monitoring System\n", - "fuel_efficiency 25.0\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 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter checks completed.\n", - "10\n", - "Parameters used: \n", - "\n", - "parking_sensors ultrasonic\n", - "driver_monitoring camera\n", - "location city\n", - "blind_spot_monitoring mirror\n", - "keyless_entry fingerprint\n", - "distance 100.0\n", - "horsepower 200.0\n", - "adaptive_cruise_control radar\n", - "pressure high\n", - "lane_departure_warning alert\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", "Parameter checks completed.\n", - "11\n", - "Parameters used: \n", - "\n", - "push_start_button button\n", - "steering_type electric\n", - "temperature 25.0\n", - "fuel_efficiency 10.0\n", - "360_degree_camera panoramic\n", - "brake_type disc\n", - "time morning\n", - "traffic_sign_recognition AI-powered\n", - "electronic_stability_control advanced\n", - "altitude 1000.0\n", - "direction north\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\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 '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", - "12\n", - "Parameters used: \n", - "\n", - "humidity high\n", - "remote_start keyless\n", - "navigation_system GPS\n", - "push_start_button button\n", - "speed_limit 60.0\n", - "torque 200.0\n", - "adaptive_cruise_control lane_centering\n", - "electronic_stability_control ESC\n", - "pressure high\n", - "brake_type disc\n", - "transmission_type automatic\n", - "speed 120.0\n", - "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter checks completed.\n", - "13\n", - "Parameters used: \n", - "\n", - "voice_command Siri\n", - "blind_spot_monitoring Rearview Camera\n", - "driver_monitoring Eye Tracking\n", - "anti_lock_brake_system ABS\n", - "seat_type Heated Seats\n", - "360_degree_camera Panoramic View\n", - "traffic_sign_recognition AI-powered Signs\n", - "speed_limit 65.0\n", - "horsepower 300.0\n", - "pressure High Pressure\n", - "fuel_efficiency Hybrid Engine\n", - "humidity 60.0\n", - "push_start_button Touchscreen Button\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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\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 checks completed.\n", - "14\n", - "Parameters used: \n", - "\n", - "temperature 25.0\n", - "transmission_type automatic\n", - "remote_start True\n", - "push_start_button False\n", - "horsepower 200.0\n", - "anti_lock_brake_system ABS\n", - "humidity 60.0\n", - "fuel_level 0.75\n", - "torque 300.0\n", - "keyless_entry keyfob\n", - "automatic_emergency_braking True\n", - "driver_monitoring camera\n", - "electronic_stability_control ESC\n", - "steering_type power\n", - "Parameter 'remote_start' has an invalid type. Expected 'str', but got 'bool'.\n", - "Parameter 'push_start_button' has an invalid type. Expected 'str', but got 'bool'.\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 'automatic_emergency_braking' has an invalid type. Expected 'str', but got 'bool'.\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 'time' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "15\n", - "Parameters used: \n", - "\n", - "push_start_button automatic\n", - "pressure high\n", - "blind_spot_monitoring lane_departure_warning\n", - "remote_start keyless_entry\n", - "distance 500.0\n", - "traffic_sign_recognition speed_limit_signs\n", - "direction north\n", - "engine_size v8\n", - "anti_lock_brake_system electronic_control\n", - "smartphone_app android\n", - "rear_view_camera backup_camera\n", - "humidity 60.0\n", - "temperature 25.0\n", - "blind_spot_monitor side_blind_spot_warning\n", - "electronic_stability_control dynamic_stability_control\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\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 '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", - "16\n", - "Parameters used: \n", - "\n", - "suspension_type electronic\n", - "voice_command natural_language\n", - "gear_ratio 4.5\n", - "traffic_sign_recognition computer_vision\n", - "transmission_type automatic\n", - "lane_departure_warning camera_based\n", - "navigation_system GPS\n", - "brake_type regenerative_braking\n", - "pressure high\n", - "fuel_level 0.75\n", - "keyless_entry rfid\n", - "push_start_button touchscreen\n", - "temperature 25.0\n", - "seat_type heated\n", - "engine_size 2.5\n", - "360_degree_camera ultrawide\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 checks completed.\n", - "17\n", - "Parameters used: \n", - "\n", - "humidity 0.0\n", - "speed_limit 100.0\n", - "smartphone_app Android\n", - "distance 500.0\n", - "location New York\n", - "blind_spot_monitor Rear View Camera\n", - "lane_centering Lane Departure Warning\n", - "suspension_type MacPherson Strut\n", - "remote_start Keyless Entry\n", - "airbag_type Dual Airbags\n", - "speed 60.0\n", - "seat_type Heated Seats\n", - "parking_sonar 360-Degree Parking Sensors\n", - "direction North\n", - "parking_sensors Ultrasonic Sensors\n", - "push_start_button Start Button on Steering Wheel\n", - "steering_type Electric Power Steering\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", - "18\n", - "Parameters used: \n", - "\n", - "blind_spot_monitoring Lane Departure Warning System\n", - "driver_monitoring Driver Fatigue Monitoring System\n", - "360_degree_camera Panoramic Camera\n", - "parking_sonar Ultrasonic Parking Sensor\n", - "navigation_system GPS Navigation\n", - "speed_limit 65.0\n", - "time Daytime\n", - "voice_command Voice Assistant\n", - "altitude 1000.0\n", - "brake_type Regenerative Braking System\n", - "traffic_sign_recognition Computer Vision-Based Recognition\n", - "horsepower 200.0\n", - "pressure High Pressure\n", - "temperature 25.0\n", - "rear_view_camera Wide-Angle Rear View Camera\n", - "seat_type Heated Seats\n", - "speed 60.0\n", - "transmission_type Automatic Transmission\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\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 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", + "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "19\n", - "Parameters used: \n", - "\n", - "fuel_level 0.5\n", - "speed_limit 120.0\n", - "torque 200.0\n", - "engine_size 2.0\n", - "airbag_type Dual Airbags\n", - "lane_centering Lane Departure Warning\n", - "parking_sonar Front and Rear Parking Sensors\n", - "location New York\n", - "brake_type Disc Brakes\n", - "seat_type Heated Seats\n", - "keyless_entry Keyless Entry with Push Start\n", - "360_degree_camera 4 Camera System\n", - "rear_view_camera Rear View Camera\n", - "pressure High Pressure\n", - "fuel_efficiency 25.0\n", - "navigation_system GPS Navigation\n", - "blind_spot_monitoring Blind Spot Monitoring\n", - "driver_monitoring Driver Attention Monitor\n", - "steering_type Power Steering\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 '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 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", "Parameter checks completed.\n", - "20\n", - "Error with the tool\n", - "21\n", - "Parameters used: \n", - "\n", - "seat_type leather\n", - "time morning\n", - "keyless_entry fingerprint\n", - "adaptive_cruise_control lane_centering\n", - "horsepower 300.0\n", - "torque 400.0\n", - "anti_lock_brake_system electronic\n", - "lane_centering camera_based\n", - "direction north\n", - "smartphone_app android\n", - "driver_monitoring eye_tracking\n", - "lane_departure_warning audible_alert\n", - "rear_view_camera wide_angle\n", - "push_start_button paddle_shift\n", - "suspension_type adaptive_damping\n", - "navigation_system satellite_based\n", - "remote_start key_fob\n", - "parking_sonar ultrasonic\n", - "gear_ratio 4.5\n", - "blind_spot_monitoring mirror_based\n", - "temperature 22.0\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'float'.\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 '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", - "22\n", - "Parameters used: \n", - "\n", - "parking_sensors ultrasonic\n", - "smartphone_app android\n", - "electronic_stability_control ESC\n", - "parking_sonar sonar_system\n", - "temperature 25.0\n", - "altitude 1000.0\n", - "suspension_type coil_over_shock\n", - "pressure high\n", - "automatic_emergency_braking AEB\n", - "360_degree_camera panoramic_camera\n", - "push_start_button keyless_entry\n", - "seat_type heated_seat\n", - "speed 60.0\n", - "remote_start key_fob\n", - "horsepower 300.0\n", - "distance 500.0\n", - "humidity 50.0\n", - "steering_type electric_power_steering\n", - "lane_centering lane_departure_warning\n", - "adaptive_cruise_control ACC\n", - "gear_ratio 4.5\n", - "torque 400.0\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "23\n", - "Parameters used: \n", - "\n", - "distance 10\n", - "keyless_entry fingerprint\n", - "fuel_level 75\n", - "humidity 60\n", - "navigation_system GPS\n", - "brake_type disc\n", - "location [37.7749, -122.4194]\n", - "blind_spot_monitor camera\n", - "automatic_emergency_braking yes\n", - "electronic_stability_control yes\n", - "traffic_sign_recognition AI\n", - "airbag_type dual\n", - "blind_spot_monitoring radar\n", - "lane_departure_warning audio\n", - "push_start_button keyless\n", - "360_degree_camera yes\n", - "altitude 1000\n", - "gear_ratio 4.5\n", - "smartphone_app Android\n", - "engine_size 2.0L\n", - "horsepower 150\n", - "remote_start yes\n", - "pressure high\n", - "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 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", - "Parameter checks completed.\n", - "24\n", - "Parameters used: \n", - "\n", - "airbag_type Dual Airbag\n", - "360_degree_camera High-Definition Camera\n", - "automatic_emergency_braking Advanced Emergency Braking System\n", - "speed 120.0\n", - "smartphone_app SmartDrive App\n", - "engine_size 2.0L Turbocharged Engine\n", - "parking_sonar Multi-Angle Parking Sonar\n", - "voice_command Voice Command System\n", - "speed_limit 65.0\n", - "fuel_efficiency Up to 30 MPG\n", - "suspension_type Adaptive Suspension\n", - "time Morning\n", - "traffic_sign_recognition Advanced Traffic Sign Recognition\n", - "driver_monitoring Driver Attention Monitoring\n", - "temperature 75.0\n", - "blind_spot_monitoring Blind Spot Information System\n", - "transmission_type 8-Speed Automatic Transmission\n", - "brake_type Regenerative Braking System\n", - "electronic_stability_control Electronic Stability Control System\n", - "pressure High Pressure\n", - "navigation_system GPS Navigation System\n", - "direction Northbound\n", - "gear_ratio 3.5\n", - "location City Center\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'time' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "25\n", - "Parameters used: \n", - "\n", - "time morning\n", - "brake_type disc brake\n", - "speed 60.0\n", - "gear_ratio 3.5\n", - "transmission_type automatic\n", - "seat_type leather\n", - "distance 100.0\n", - "pressure high\n", - "keyless_entry push button start\n", - "direction north\n", - "speed_limit 70.0\n", - "lane_centering camera based\n", - "adaptive_cruise_control radar based\n", - "suspension_type macpherson strut\n", - "lane_departure_warning visual alert\n", - "electronic_stability_control ESC\n", - "rear_view_camera backup camera\n", - "temperature 25.0\n", - "airbag_type dual airbag\n", - "parking_sonar ultrasonic sensor\n", - "location city center\n", - "automatic_emergency_braking autonomous emergency braking\n", - "fuel_level 0.75\n", - "navigation_system GPS navigation\n", - "360_degree_camera panoramic camera\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 '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", + "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 '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", - "26\n", - "Parameters used: \n", - "\n", - "remote_start keyless_entry\n", - "altitude high\n", - "humidity low\n", - "electronic_stability_control adaptive_cruise_control\n", - "rear_view_camera blind_spot_monitoring\n", - "location city\n", - "navigation_system GPS\n", - "temperature hot\n", - "engine_size large\n", - "speed fast\n", - "smartphone_app Android\n", - "gear_ratio automatic\n", - "fuel_level full\n", - "horsepower high\n", - "lane_departure_warning active\n", - "steering_type electric\n", - "time day\n", - "speed_limit 60mph\n", - "keyless_entry fingerprint\n", - "adaptive_cruise_control lane_centering\n", - "blind_spot_monitoring rear_view\n", - "torque high\n", - "seat_type heated\n", - "pressure high\n", - "anti_lock_brake_system ABS\n", - "airbag_type dual\n", - "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'speed' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\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 '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 'engine_size' 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 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", + "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", "Parameter checks completed.\n", - "27\n", - "Parameters used: \n", - "\n", - "lane_departure_warning Lane Departure Warning System\n", - "airbag_type Dual Airbag\n", - "distance 100.0\n", - "360_degree_camera Panoramic Camera\n", - "transmission_type Automatic Transmission\n", - "pressure High Pressure\n", - "traffic_sign_recognition Traffic Sign Recognition System\n", - "push_start_button Push Start Button\n", - "blind_spot_monitor Blind Spot Monitor\n", - "anti_lock_brake_system Anti-Lock Brake System\n", - "horsepower 200.0\n", - "humidity 60.0\n", - "engine_size 2.0L\n", - "parking_sensors Parking Sensors\n", - "temperature 25.0\n", - "adaptive_cruise_control Adaptive Cruise Control\n", - "speed_limit 120.0\n", - "gear_ratio 4.5\n", - "electronic_stability_control Electronic Stability Control\n", - "direction North\n", - "steering_type Power Steering\n", - "torque 300.0\n", - "driver_monitoring Driver Monitoring System\n", - "blind_spot_monitoring Blind Spot Monitoring System\n", - "location New York\n", - "altitude 1000.0\n", - "seat_type Heated Seat\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 '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 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", "Parameter checks completed.\n", - "28\n", - "Parameters used: \n", - "\n", - "anti_lock_brake_system ABS\n", - "voice_command Siri\n", - "parking_sensors Ultrasonic\n", - "gear_ratio 4.2\n", - "parking_sonar Radar\n", - "pressure High\n", - "lane_centering Laser\n", - "horsepower 300.0\n", - "360_degree_camera Panoramic\n", - "speed 120.0\n", - "brake_type Disc\n", - "blind_spot_monitoring Camera\n", - "speed_limit 65.0\n", - "airbag_type Dual\n", - "remote_start Keyless\n", - "blind_spot_monitor Ultrasonic\n", - "driver_monitoring Eye-tracking\n", - "time Morning\n", - "humidity 60.0\n", - "lane_departure_warning Laser\n", - "adaptive_cruise_control Radar\n", - "automatic_emergency_braking Camera\n", - "temperature 25.0\n", - "torque 400.0\n", - "suspension_type MacPherson\n", - "smartphone_app Android\n", - "location City\n", - "distance 100.0\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 '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 'time' has an invalid type. Expected 'int', but got 'str'.\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 'horsepower' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "29\n", - "Parameters used: \n", - "\n", - "navigation_system GPS\n", - "distance 100.0\n", - "airbag_type Dual Airbags\n", - "torque 200.0\n", - "temperature 25.0\n", - "location New York\n", - "brake_type Disc Brakes\n", - "lane_departure_warning Active Lane Departure Warning\n", - "360_degree_camera Panoramic View Camera\n", - "altitude 1000.0\n", - "seat_type Heated Seats\n", - "rear_view_camera Rearview Camera\n", - "lane_centering Lane Centering System\n", - "automatic_emergency_braking Automatic Emergency Braking\n", - "speed 60.0\n", - "parking_sonar Parking Sonar System\n", - "remote_start Remote Start System\n", - "smartphone_app Smartphone App Connectivity\n", - "fuel_efficiency High Fuel Efficiency\n", - "electronic_stability_control Electronic Stability Control\n", - "driver_monitoring Driver Monitoring System\n", - "time 10:00 AM\n", - "gear_ratio 3.5\n", - "pressure High Pressure\n", - "direction North\n", - "anti_lock_brake_system Anti-Lock Braking System\n", - "blind_spot_monitoring Blind Spot Monitoring System\n", - "speed_limit 65.0\n", - "horsepower 300.0\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 '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 checks completed.\n", - "30\n", - "Parameters used: \n", - "\n", - "torque string\n", - "seat_type integer\n", - "360_degree_camera boolean\n", - "speed_limit float\n", - "adaptive_cruise_control array\n", - "push_start_button null\n", - "anti_lock_brake_system object\n", - "suspension_type string\n", - "blind_spot_monitoring number\n", - "automatic_emergency_braking integer\n", - "voice_command boolean\n", - "location string\n", - "distance array\n", - "gear_ratio object\n", - "pressure null\n", - "temperature float\n", - "fuel_level string\n", - "rear_view_camera boolean\n", - "driver_monitoring number\n", - "keyless_entry integer\n", - "brake_type object\n", - "horsepower array\n", - "navigation_system string\n", - "engine_size float\n", - "airbag_type null\n", - "humidity float\n", - "time string\n", - "electronic_stability_control boolean\n", - "remote_start integer\n", - "lane_departure_warning object\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 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", + "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter checks completed.\n", - "31\n", - "Parameters used: \n", - "\n", - "blind_spot_monitoring Lane Departure Warning System\n", - "brake_type Disc Brake\n", - "direction Forward\n", - "horsepower 300.0\n", - "push_start_button Push Button Start\n", - "navigation_system GPS Navigation\n", - "gear_ratio 4.5\n", - "location City\n", - "adaptive_cruise_control Adaptive Cruise Control\n", - "suspension_type MacPherson Strut\n", - "airbag_type Dual Airbag\n", - "360_degree_camera 360 Degree Camera\n", - "voice_command Voice Command System\n", - "fuel_level 75.0\n", - "seat_type Heated Seat\n", - "distance 100.0\n", - "anti_lock_brake_system Anti-Lock Brake System\n", - "engine_size 2.0\n", - "remote_start Remote Start System\n", - "smartphone_app Smartphone App\n", - "parking_sensors Parking Sensors\n", - "transmission_type Automatic Transmission\n", - "blind_spot_monitor Blind Spot Monitor\n", - "speed_limit 60.0\n", - "automatic_emergency_braking Automatic Emergency Braking\n", - "fuel_efficiency 25.0\n", - "driver_monitoring Driver Monitoring System\n", - "humidity 50.0\n", - "torque 250.0\n", - "lane_departure_warning Lane Departure Warning\n", - "time 10:00 AM\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 '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 'engine_size' 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 '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 '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 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 '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 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 'horsepower' 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 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter checks completed.\n", - "32\n", - "Parameters used: \n", - "\n", - "360_degree_camera Panoramic Camera\n", - "driver_monitoring Advanced Driver Monitoring System\n", - "fuel_efficiency Hybrid Fuel Efficiency\n", - "torque Electric Torque\n", - "steering_type Steer-by-Wire Steering\n", - "parking_sonar Multi-Mode Parking Sonar\n", - "altitude 1000.0\n", - "push_start_button Keyless Push Start Button\n", - "lane_departure_warning Lane Departure Warning System\n", - "rear_view_camera Wide-Angle Rear View Camera\n", - "remote_start Remote Engine Start System\n", - "transmission_type Automatic Transmission\n", - "speed 120.0\n", - "smartphone_app Smartphone App Connectivity\n", - "automatic_emergency_braking Advanced Automatic Emergency Braking\n", - "horsepower 300.0\n", - "lane_centering Lane Centering Assist\n", - "seat_type Heated and Cooled Seats\n", - "direction North\n", - "keyless_entry Keyless Entry System\n", - "navigation_system GPS Navigation System\n", - "traffic_sign_recognition Traffic Sign Recognition System\n", - "pressure High Pressure\n", - "fuel_level 75.0\n", - "voice_command Voice Command System\n", - "temperature 25.0\n", - "adaptive_cruise_control Adaptive Cruise Control System\n", - "location New York City\n", - "electronic_stability_control Electronic Stability Control System\n", - "blind_spot_monitoring Blind Spot Monitoring System\n", - "speed_limit 65.0\n", - "gear_ratio 4.5\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\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 '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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "33\n", - "Parameters used: \n", - "\n", - "fuel_level 0.5\n", - "parking_sonar ultrasonic\n", - "adaptive_cruise_control lane_centering\n", - "fuel_efficiency gasoline\n", - "parking_sensors rear_view_camera\n", - "altitude 1000.0\n", - "rear_view_camera wide_angle\n", - "lane_departure_warning audible_alert\n", - "steering_type electric_power_steering\n", - "transmission_type automatic\n", - "remote_start keyless_entry\n", - "speed_limit 60.0\n", - "brake_type disc_brakes\n", - "push_start_button smartphone_app\n", - "smartphone_app android\n", - "blind_spot_monitoring visual_alert\n", - "time morning\n", - "humidity 0.7\n", - "lane_centering adaptive_lane_centering\n", - "pressure high_pressure\n", - "distance 500.0\n", - "navigation_system gps_navigation\n", - "automatic_emergency_braking full_auto_braking\n", - "voice_command natural_language_processing\n", - "driver_monitoring eye_tracking\n", - "360_degree_camera panoramic_view\n", - "direction northbound\n", - "seat_type heated_seat\n", - "keyless_entry proximity_sensor\n", - "electronic_stability_control electronic_stability_program\n", - "traffic_sign_recognition machine_learning_based\n", - "horsepower 200.0\n", - "location city_center\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\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 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\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 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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", - "34\n", - "Parameters used: \n", - "\n", - "blind_spot_monitoring Lane Departure Warning System\n", - "360_degree_camera Panoramic Camera\n", - "altitude 1000.0\n", - "time 12:00 PM\n", - "automatic_emergency_braking Autonomous Emergency Braking\n", - "electronic_stability_control Electronic Stability Control\n", - "temperature 25.0\n", - "speed 60.0\n", - "pressure High Pressure\n", - "navigation_system GPS Navigation\n", - "blind_spot_monitor Blind Spot Monitor\n", - "adaptive_cruise_control Adaptive Cruise Control\n", - "fuel_level 75.0\n", - "transmission_type Automatic Transmission\n", - "lane_centering Lane Centering System\n", - "parking_sonar Parking Sonar System\n", - "lane_departure_warning Lane Departure Warning System\n", - "engine_size 2.0L Engine\n", - "keyless_entry Keyless Entry System\n", - "humidity 60.0\n", - "distance 100.0\n", - "traffic_sign_recognition Traffic Sign Recognition System\n", - "rear_view_camera Rear View Camera\n", - "gear_ratio 3.5\n", - "remote_start Remote Start System\n", - "horsepower 200.0\n", - "location New York City\n", - "suspension_type MacPherson Strut Suspension\n", - "parking_sensors Parking Sensors System\n", - "voice_command Voice Command System\n", - "push_start_button Push Start Button System\n", - "airbag_type Dual Airbag System\n", - "fuel_efficiency 25.0\n", - "torque 250.0\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\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 '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 'speed_limit' 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 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "35\n", - "Error with the tool\n", - "36\n", - "Parameters used: \n", - "\n", - "seat_type leather\n", - "altitude 1000.0\n", - "automatic_emergency_braking yes\n", - "lane_centering active\n", - "torque 200.0\n", - "lane_departure_warning audible\n", - "smartphone_app android\n", - "transmission_type automatic\n", - "keyless_entry fingerprint\n", - "adaptive_cruise_control speed\n", - "blind_spot_monitoring camera\n", - "voice_command natural_language\n", - "gear_ratio 4.0\n", - "fuel_efficiency high\n", - "electronic_stability_control active\n", - "location city\n", - "rear_view_camera wide_angle\n", - "direction north\n", - "push_start_button button\n", - "airbag_type dual\n", - "anti_lock_brake_system ABS\n", - "brake_type disc\n", - "navigation_system GPS\n", - "horsepower 300.0\n", - "humidity 60.0\n", - "speed_limit 65.0\n", - "traffic_sign_recognition camera\n", - "parking_sonar ultrasonic\n", - "blind_spot_monitor camera\n", - "time morning\n", - "distance 50.0\n", - "360_degree_camera panoramic\n", - "pressure high\n", - "driver_monitoring eye_tracking\n", - "fuel_level 75.0\n", - "engine_size 2.0\n", - "Parameter 'altitude' has an invalid type. Expected 'str', but got 'float'.\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\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 '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 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", - "37\n", - "Parameters used: \n", - "\n", - "airbag_type Dual Airbag\n", - "anti_lock_brake_system Electronic Brakeforce Distribution (EBD)\n", - "direction Forward\n", - "voice_command Voice Command System\n", - "smartphone_app Smartphone App Integration\n", - "rear_view_camera Rear View Camera\n", - "fuel_level Full\n", - "navigation_system GPS Navigation\n", - "parking_sensors Parking Sensors\n", - "steering_type Power Steering\n", - "blind_spot_monitor Blind Spot Monitor\n", - "speed 120.0\n", - "lane_departure_warning Lane Departure Warning System\n", - "torque 300.0\n", - "location New York\n", - "transmission_type Automatic Transmission\n", - "lane_centering Lane Centering System\n", - "blind_spot_monitoring Blind Spot Monitoring System\n", - "traffic_sign_recognition Traffic Sign Recognition System\n", - "fuel_efficiency High Fuel Efficiency\n", - "pressure High Pressure\n", - "speed_limit 65.0\n", - "brake_type Disc Brake\n", - "push_start_button Push Start Button\n", - "horsepower 200.0\n", - "temperature 25.0\n", - "suspension_type MacPherson Strut Suspension\n", - "seat_type Heated Seats\n", - "time 10:00 AM\n", - "electronic_stability_control Electronic Stability Control (ESC)\n", - "automatic_emergency_braking Automatic Emergency Braking System\n", - "altitude 1000.0\n", - "parking_sonar Parking Sonar System\n", - "adaptive_cruise_control Adaptive Cruise Control System\n", - "remote_start Remote Start System\n", - "humidity 60.0\n", - "driver_monitoring Driver Monitoring System\n", - "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 '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 'str'.\n", - "Parameter 'altitude' has an invalid type. Expected 'str', 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", - "38\n", - "Error with the tool\n", "39\n", - "Parameters used: \n", - "\n", - "brake_type disc brake\n", - "push_start_button keyless start button\n", - "360_degree_camera high-definition camera\n", - "keyless_entry fingerprint recognition\n", - "lane_centering electronic power steering\n", - "parking_sonar ultrasonic sensors\n", - "suspension_type adaptive suspension\n", - "driver_monitoring facial recognition\n", - "engine_size 2.0L\n", - "adaptive_cruise_control radar-based system\n", - "transmission_type automatic transmission\n", - "torque 300 Nm\n", - "automatic_emergency_braking collision avoidance system\n", - "electronic_stability_control electronic stability program\n", - "location New York City\n", - "navigation_system GPS navigation\n", - "fuel_level full tank\n", - "remote_start smartphone app\n", - "steering_type power steering\n", - "parking_sensors ultrasonic sensors\n", - "seat_type heated seats\n", - "horsepower 200 HP\n", - "temperature 20°C\n", - "lane_departure_warning visual alert system\n", - "voice_command natural language processing\n", - "airbag_type multi-stage airbags\n", - "humidity 60%\n", - "smartphone_app Android app\n", - "gear_ratio 6-speed transmission\n", - "blind_spot_monitor camera-based system\n", - "speed_limit 65 mph\n", - "time 10:00 AM\n", - "rear_view_camera high-definition camera\n", - "pressure normal pressure\n", - "distance 100 miles\n", - "fuel_efficiency 25 mpg\n", - "blind_spot_monitoring camera-based system\n", - "direction northbound\n", - "altitude 500 ft\n", - "Parameter 'engine_size' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'humidity' has an invalid type. Expected 'int', 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 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\n", - "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'fuel_efficiency' has an invalid type. Expected 'float', but got 'str'.\n", + "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 '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" ] } @@ -1241,12 +944,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1287,12 +990,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1332,6 +1035,46 @@ "plt.legend()\n", "plt.show()\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "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_dot_5_.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.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": { 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 2be5bc5..963cc0d 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -33,11 +33,7 @@ def get_params(i): session_id= session_id, stream=False, ) - # for log in EventLogger().log(response): - # log.print() steps = response.steps - # for step in steps: - # print(step) param = steps[1].tool_calls[0].arguments['param'] if isinstance(param, str): try: @@ -65,11 +61,29 @@ def get_params(i): def test_abitrary_client_tool(all_params): arbitrary_client_tool = ArbitraryClientTool(all_params) - agent = Agent(client, - model="meta-llama/Llama-3.1-8B-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.", - tools=[arbitrary_client_tool] + 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.5, + "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") @@ -78,9 +92,6 @@ def test_abitrary_client_tool(all_params): session_id= session_id, stream=False, ) - - # for log in EventLogger().log(response): - # log.print() return response def main(): diff --git a/experiments/tools.py b/experiments/tools.py index a226f15..19dc36f 100644 --- a/experiments/tools.py +++ b/experiments/tools.py @@ -4,7 +4,7 @@ class ArbitraryClientTool(ClientTool): """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. """ From 5d865336b1f95304ff35b650008d2cb0c5c86d0a Mon Sep 17 00:00:00 2001 From: EoghanOConnor Date: Tue, 25 Mar 2025 16:54:53 +0000 Subject: [PATCH 9/9] markdowns added --- .../ollama_3_2_3B_temp_0.001.csv | 40 +++ .../max_param_analysis.ipynb | 228 ++++++++++-------- .../max_params_per_tool.py | 2 +- 3 files changed, 165 insertions(+), 105 deletions(-) create mode 100644 experiments/max_params_per_tool/experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv 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/max_param_analysis.ipynb b/experiments/max_params_per_tool/max_param_analysis.ipynb index 75d1b27..8e35c0f 100644 --- a/experiments/max_params_per_tool/max_param_analysis.ipynb +++ b/experiments/max_params_per_tool/max_param_analysis.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -22,9 +22,16 @@ "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": 3, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -85,29 +92,19 @@ } ], "source": [ - "get_params = get_params(50)" + "all_params = get_params(50)" ] }, { - "cell_type": "code", - "execution_count": 4, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting test: ['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" - ] - } - ], "source": [ - "print(f\"Starting test: {get_params['name']}\")" + "## Removing any duplicate parameters" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -130,29 +127,29 @@ "indices_to_remove = []\n", "\n", "# Iterate over the 'name' list\n", - "for i in range(len(get_params['name'])):\n", - " if get_params['name'][i] in seen_names:\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: {get_params['name'][i]}\")\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(get_params['name'][i])\n", + " seen_names.add(all_params['name'][i])\n", "\n", "# Remove the entries that have duplicates in 'name'\n", - "get_params['name'] = [get_params['name'][i] for i in range(len(get_params['name'])) if i not in indices_to_remove]\n", - "get_params['type'] = [get_params['type'][i] for i in range(len(get_params['type'])) if i not in indices_to_remove]\n", - "get_params['description'] = [get_params['description'][i] for i in range(len(get_params['description'])) if i not in indices_to_remove]\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 get_params\n", + "# Output the cleaned all_params\n", "print(\"Data cleaned (duplicates removed): \\n\")\n", - "for param in get_params:\n", - " print(param, get_params[param])\n" + "for param in all_params:\n", + " print(param, all_params[param])\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -164,12 +161,12 @@ } ], "source": [ - "print(len(get_params['name']))" + "print(len(all_params['name']))" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -231,6 +228,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", "Parameter checks completed.\n", "4\n" ] @@ -247,7 +245,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", + "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" ] @@ -280,8 +279,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\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 checks completed.\n", "7\n" ] @@ -298,7 +297,7 @@ "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", "8\n" ] @@ -315,8 +314,6 @@ "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 checks completed.\n", "9\n" ] @@ -333,9 +330,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\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", "10\n" ] @@ -353,6 +349,7 @@ "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" ] @@ -369,7 +366,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'time' has an invalid type. Expected 'int', but got 'float'.\n", + "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" ] @@ -386,8 +385,7 @@ "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 'humidity' has an invalid type. Expected 'int', but got 'str'.\n", "Parameter checks completed.\n", "13\n" ] @@ -405,7 +403,8 @@ "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", "14\n" ] @@ -422,8 +421,9 @@ "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 checks completed.\n", "15\n" ] @@ -440,8 +440,7 @@ "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 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", "16\n" ] @@ -458,8 +457,8 @@ "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 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", "17\n" ] @@ -477,7 +476,6 @@ "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 checks completed.\n", "18\n" ] @@ -494,7 +492,7 @@ "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 checks completed.\n", "19\n" ] @@ -511,8 +509,9 @@ "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 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", "20\n" ] @@ -529,7 +528,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'humidity' has an invalid type. Expected 'int', but got 'float'.\n", + "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" @@ -547,10 +546,10 @@ "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 'engine_size' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", "22\n" ] @@ -567,14 +566,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'gear_ratio' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'distance' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'pressure' has an invalid type. Expected 'bool', but got 'str'.\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 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", "23\n" ] @@ -592,9 +586,7 @@ "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 '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", "24\n" ] @@ -611,7 +603,8 @@ "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 checks completed.\n", "25\n" @@ -630,7 +623,8 @@ "output_type": "stream", "text": [ "Parameter 'humidity' 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 'time' has an invalid type. Expected 'int', but got 'float'.\n", "Parameter checks completed.\n", "26\n" ] @@ -647,9 +641,10 @@ "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 '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" ] @@ -666,12 +661,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'time' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'fuel_level' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'torque' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'temperature' has an invalid type. Expected 'float', but got 'str'.\n", - "Parameter 'horsepower' has an invalid type. Expected 'int', but got 'str'.\n", - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'str'.\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 '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" ] @@ -688,6 +681,8 @@ "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", @@ -707,7 +702,9 @@ "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 '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" ] @@ -724,11 +721,12 @@ "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 '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" ] @@ -745,8 +743,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Parameter 'speed_limit' has an invalid type. Expected 'int', but got 'float'.\n", + "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" ] @@ -763,10 +763,10 @@ "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 '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 checks completed.\n", "33\n" ] @@ -783,9 +783,10 @@ "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 '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" @@ -803,10 +804,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "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 '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 '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", "35\n" @@ -824,10 +825,9 @@ "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 '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 checks completed.\n", "36\n" ] @@ -847,6 +847,7 @@ "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" @@ -864,11 +865,10 @@ "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 '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 '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", "38\n" ] @@ -885,16 +885,14 @@ "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 '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", "39\n", - "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 '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" @@ -908,16 +906,17 @@ "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(get_params['name'])), i)\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': [get_params['name'][idx] for idx in random_indices],\n", - " 'type': [get_params['type'][idx] for idx in random_indices],\n", - " 'description': [get_params['description'][idx] for idx in random_indices]\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(len(selected_params['name']))\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", @@ -942,14 +941,21 @@ " print(\"Parameter checks completed.\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graph showing the number of hullicination" + ] + }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -988,14 +994,21 @@ "plt.show()\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graph of Error rate for each number of parameters" + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1036,16 +1049,23 @@ "plt.show()\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Saving data" + ] + }, { "cell_type": "code", - "execution_count": null, + "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_dot_5_.csv\n" + "Data has been written to experiment_logs/max_params_single_call/ollama_3_2_3B_temp_0.001.csv\n" ] } ], @@ -1060,7 +1080,7 @@ " 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.csv'\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", 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 963cc0d..5166420 100644 --- a/experiments/max_params_per_tool/max_params_per_tool.py +++ b/experiments/max_params_per_tool/max_params_per_tool.py @@ -70,7 +70,7 @@ def test_abitrary_client_tool(all_params): sampling_params = { "strategy": { "type": "top_p", - "temperature": 0.5, + "temperature": 0.001, "top_p": 0.9, } },