[Issue]: unable to make calculator example work with local models #2953
Comments
|
Another run with a trivial calculation (all the rest is unchanged, including the underlying model 'llama3:instruct') which is called correctly but still never terminates. This shows issue 3 & 4 as described at the top. |
|
I noticed that the last output in the autogen LiteLLM with Ollama user guide seems to make similarly redundant calls despite getting the right answer. That's a different behaviour from the ones demonstrated and expected by the Tool Use tutorial, where the agent terminate the conversation with a plain English summary of the response. |
qingyun-wu
added
the
alt-models
I'll try to answer this, but please do take it with a load of salt, because this is based on my own experience and my limited understanding of how AI works. So this might be entirely correct or entirely wrong. LOL. My conclusion after several experiment, this issue is more on the models than others. There are two main factors:
Please remember function calling is not actually the AI calling functions directly. It's just another form of text generation. The main problem here is "hallucination" (I'm not sure if hallucination is the correct word for this case, hence the double quotes). If the model is not trained to use the specific function we provide, it will try to "understand" how to use it first, by trying to call it multiple times. Unfortunately, this gets worse with complex tasks. Imo, the reason is the same, if the model is not trained to solve complex tasks, in this case, complex calculation, it will try the function even more. The second factor, the AI platform, well AI platforms implement function calling differently. Let's take localai.io and litellm for examples. Litellm does not enforce how AI models generate function calling, this is the reason why we can get extra arguments for the function. It's different with localai.io, it can enforce the function definition. But, that alone only solve the extra arguments, it won't solve the problem with AI calling the same function multiple times. In addition with the model is not trained with the our function, it seems the model also get confused on how to answer. Once it uses a function, it seems to expect that everything must be solved via function calling. Localai.io solved this by adding a "no action" function, users won't see it though. Litellm doesn't have this. Perhaps litellm expect the model is smart enough to create replies without function calling. To solve this, we can add our own "no action" function. BUT, unfortunately that's all we can do. We can try to minimize the probability calling function multiple times with prompts, or how we define the functions, but the underlying issue is still there. My conclusion is, to have function calling works with local AI model we need to have the "correct" AI model for the task. Perhaps this issue can only be solved with fine tuning. To demonstrate this issue, I made a small python script, I tested it with litellm, ollama and mistral. Another example is here https://github.com/yonitjio/exploring-odoo/tree/main/calendar_bot. It demonstrate a workaround for similar issue by wrapping a several function into one function with command argument. Code: The result: |
|
@yonitjio Thank you for taking the time to reproduce the code and give some answers. That's really appreciated. From what you explained & showed, it looks like local models can overcome problem 1 (calls not matching the function signature) & 3 (never terminating). I've now experimented with larger models (e.g. mixtral:8x22b) and they are indeed better at producing inputs that match the function arguments. However the causes for problem 2 (correct decomposition of the expression into smaller parts) & 4 (agents not taking into account the function output) remains unclear to me. It looks like local models are able to properly decompose the expression when they don't have to call a function. Here's an example of a chat with mixtral (using ollama): Prompt: Given a function f(operand1, operand2, operator), call f as many times as necessary to resolve the following calculation: (44232 + 13312 / (232 - 32)) * 5. Response: This is logically correct. The question is why is the agent unable to work as well when producing function inputs (problem 2)? Problem 4 remains a mystery to me. In the execution log you've have shared, my understanding is that the function never returns 4, because the agent never builds on the previous output (2) to send the following input (2, 2, *). In your example, the model give the correct answer "4" at the end by bypassing the calculator entirely. I don't see much sign that it uses previous outputs.
I don't understand why no local model seem to be able to build on previous output to progress with resolving the expression. Just like the Autogen calculator example using OpenAI does. And I still wonder if this problem is b/c:
So my question remain. If anyone is able to make the example work with a local model I'd love to hear how. If not I'd like to know where the limitation lies exactly. |
|
Well, so far my understanding is, it is mainly the models. They just aren't that good with these kind of task, i.e., not trained for the task. This also should be the reason why it can answer 2 * 2 = 4 without using calculator, because 2*2=4 was in the training data. I guess it's similar on how we know by "heart", 2*2=4. Silly, but I can't think any other answer. Well there's other possibility that it was just winging it... LOL. As I mentioned before, there are other factors, in your case, using litellm helps since Ollama's Open AI API implementation doesn't support function calling yet, but litellm does with a limitation. The limitation is, it works by adding prompts for the function call. Unfortunately, different models may use different prompt format. Afaik, using different format than what the model was train on, degrades its performance. And as for Autogen, well, I would not call it a shortcoming, but since this is about generative text after all, generally it does contribute to everything because of the default prompts which may not suitable for the model when it's used, but imo, in this example it doesn't have anything at all to the issue. So, to answer your question, imo, the only way to make the calculator example works "perfectly" is to finetune the model to use the calculator function and use the prompt format that the model was trained on. Otherwise, it just the same with everything else, which is finding the better prompt and hope it works all the time. Btw, I did add this in the prompt |
|
Interesting... I hadn't considering the 'extra' arguments problem, but it's a good point. I just wrote 'tools for the toolless' (so essentially the very models under discussion), and I will look at adding some 'guiderails' to avoid picking up extra arguments, either rejecting fully (which I do if it makes a tool call for something not in the tool list, like making up a 'talk_to_user' tool, with argument of message="Yes, I did the thing")
Btw, I find the opposite problem: it'll use tools only if prompted to do so.... |
Describe the issue
No matter which local model I use the calculator example from the autogen Tool Use tutorial fails in various ways:
{"a": 44232, "b": 13312, "operator": "/", "c": 232, "d": 32}){"a": 44232, "b": 13312, "operator": "+"});I would like to know:
More generally the issue for me is that despite the autogen tutorial giving examples and ways to adapt them for local models, those instructions together don't seem to work with a large number of local models. So, perhaps, either the documentation should acknowledge that limitation upfront (and point to the technical reasons) or it should be more specific on how to make the example work. Knowing where the limitations are (autogen, model, litellm or ollama?) would be
very helpful.
Steps to reproduce
In the output log below which exhibits all the 4 issues described above.
Screenshots and logs
Additional Information
The text was updated successfully, but these errors were encountered: