Do different function-calling subtasks have different entropy profiles during training?
This explores whether the distinct pieces of function calling — picking which function, filling parameters, chaining calls, writing the final response — each show their own pattern of confidence/uncertainty as a model trains, rather than function calling behaving as one uniform task.
This reads the question as asking whether function calling's internal subtasks each carry a different entropy signature during training — and the corpus doesn't have a paper that measures this head-on, but it has the three ingredients to build the case, and they point to 'yes.'
Start with the fact that function calling isn't one task. Granite-20B's work shows it decomposes into seven distinct subtasks — nested calls, chaining, parallel functions, function-name detection, parameter detection, next-best-function selection, and response generation — and that training each explicitly beats lumping them under one umbrella dataset Can breaking function calling into subtasks improve model generalization?. That matters here because those seven aren't the same *kind* of task. Name detection and parameter detection are closed, rigid, format-bound choices; response generation is open-ended natural language. The corpus's clearest entropy result is that this distinction is exactly what governs entropy trajectories: structured domains drive output entropy *down* during training while creative/open-ended ones drive it *up*, and the order you train them in mechanically reshapes the curve — train the structured tasks first and you avoid entropy collapse damaging the open-ended ones Does training order reshape how models handle different task types?. Map that onto function calling and you'd predict parameter detection collapsing toward low entropy while response generation stays high — different profiles within the same 'task.'
The token-level evidence sharpens it. Only about 20% of tokens are high-entropy 'forking points,' and reinforcement learning mostly adjusts those decision tokens while leaving the rest nearly fixed Do high-entropy tokens drive reasoning model improvements?. Function-calling output is mostly low-entropy scaffolding (brackets, key names, syntax) punctuated by a few genuine choices — which function, which argument value. So even *within* a single call the entropy isn't flat; it spikes at the choice points and flattens across the boilerplate. The subtasks that are all choice (next-best-function) will look very different from the ones that are mostly scaffolding (parameter formatting).
There's also a collapse story worth knowing. RL post-training tends to converge on one dominant output format early and suppress the alternatives, regardless of which format actually performs best Does RL training collapse format diversity in pretrained models?. For the rigid subtasks that's the desired behavior — you *want* parameter format to lock in. For response generation it's the failure mode Does training order reshape how models handle different task types?. The same training pressure that's healthy for one subtask is harmful for another, which is itself an argument that they don't share an entropy profile. This is partly why DPO — which hands the model explicit wrong-vs-right examples — outperforms plain supervised fine-tuning on function calling: the rigid-format failures are precisely where a model needs sharpened, low-entropy confidence that SFT doesn't reliably produce Can small models match large models on function calling?.
The thing you didn't know you wanted to know: a model lowers its own output entropy when it recognizes text as familiar/self-generated, tracking input surprise internally and modulating confidence without ever saying so Why do models produce less uncertain outputs on their own text?. So a subtask's entropy profile isn't just about how open-ended it is — it's also about how 'in-distribution' the model feels at that moment. Combine all of this and the answer is that function-calling subtasks almost certainly have divergent entropy profiles, and the practical lever the corpus hands you is training order: schedule the structured, format-locking subtasks before the open-ended response generation so collapse hardens the right things and spares the rest.
Sources 6 notes
Granite-20B-FunctionCalling shows that explicit training across seven granular subtasks—nested calls, chaining, parallel functions, name detection, parameter detection, next-best function, and response generation—generalizes better than umbrella datasets like ToolLLM. This multi-task approach closes the performance gap with GPT, Claude, and Gemini.
Omni-Thinker shows structured domains decrease output entropy while creative domains increase it. BWT-guided scheduling—training structured tasks first—yields 6.2% gains over joint training by preventing entropy collapse from damaging open-ended capabilities.
Only ~20% of tokens exhibit high entropy as pivotal reasoning decision points; RLVR primarily adjusts these forking tokens. Training exclusively on them matches or exceeds full-gradient performance, revealing that the minority carries the learning signal.
Controlled experiments show RL consistently amplifies one format distribution from pretraining within the first epoch while collapsing alternatives. The winning format depends on model scale, not necessarily performance, and is largely hidden when starting from proprietary pretrained models.
Small models fine-tuned via DPO on correct and incorrect function-calling examples from a large teacher model achieve high accuracy on logical and mathematical tasks. DPO's explicit negative examples directly target the rigid output format failures where SFT alone underperforms.
Post-trained models produce 3-4x lower output entropy on their own generations, driven by an internal representation of input surprise that causally modulates confidence. This implicit self-recognition signal appears without being verbalized, encoded directly in the output distribution.