💬 NLP

Losses that Cook: Topological Optimal Transport for Structured Recipe Generation

This paper introduces a topological optimal transport loss and other composite objectives to improve structured recipe generation, demonstrating significant gains in ingredient accuracy, procedural coherence, and human preference compared to standard cross-entropy training.

Original authors: Mattia Ottoborgo, Daniele Rege Cambrin, Paolo Garza

Published 2026-04-20

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Mattia Ottoborgo, Daniele Rege Cambrin, Paolo Garza

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot chef how to cook. You want it to write a perfect recipe for "Spaghetti Carbonara."

If you just tell the robot, "Write a recipe that sounds good," it might give you a beautifully written paragraph that flows perfectly. But if you look closely, you might realize it forgot the eggs, told you to fry the pasta in ice water, or said to cook it for 100 hours. The text is fluent, but the recipe is useless.

This paper is about teaching the robot chef to care about what it says, not just how it sounds.

Here is the breakdown of their solution, using some kitchen metaphors:

1. The Problem: The "Fluency Trap"

Standard AI training is like a strict English teacher who only cares about grammar and spelling.

The Old Way (Cross-Entropy): The teacher gives the robot a gold star for every word it gets right. If the robot writes "boil the water," it gets a star. If it writes "boil the ice," it gets a star because the grammar is perfect.
The Result: The robot learns to sound like a poet but fails to be a chef. It might hallucinate ingredients (like "chocolate sauce" in a pasta dish) or get the math wrong (using 100 eggs for one person).

2. The Solution: A New Kind of "Recipe Score"

The authors invented a new way to grade the robot's homework. Instead of just checking word-by-word, they introduced two new "judges":

Judge A: The Topological Loss (The "Cloud Matcher")

Imagine the ingredients of a recipe (flour, eggs, salt) are not just words, but dots floating in a 3D space.

The Gold Standard: A perfect recipe has a specific shape made of dots. "Eggs" is close to "yolks," and "flour" is close to "sugar."
The Robot's Mistake: If the robot swaps "salt" for "pepper," the shape of its dot-cloud changes slightly. If it forgets the eggs entirely, a huge chunk of the cloud disappears.
The Magic: The new loss function measures the distance between the robot's cloud and the perfect cloud. It forces the robot to arrange its ingredients in the same "geometric shape" as a real recipe. It doesn't just check if the word "egg" is there; it checks if the concept of eggs is in the right place in the recipe's structure.

Judge B: The Dice Loss (The "Ingredient Checklist")

This judge is like a strict grocery shopper holding a checklist.

How it works: It looks at the list of ingredients the robot generated and compares it to the real list. It asks: "Did you get the flour? Yes. Did you get the eggs? Yes. Did you forget the salt? No!"
The Result: This is amazing at making sure the robot doesn't forget critical items and gets the numbers (quantities) right. It's great for precision.

3. The "Mixed" Strategy

The authors found that using just one judge wasn't enough.

The Cloud Matcher (Topological) was great at making sure the ingredients made sense together.
The Checklist (Dice) was great at making sure the numbers and specific items were exact.
The Winner: They combined them into a "Mixed Loss." It's like hiring a team of judges: one checks the overall vibe and structure, and the other checks the specific details.

4. The Results: From "Poet" to "Chef"

When they tested this new method:

The Robot became a better chef: It stopped forgetting ingredients (like the eggs in Carbonara).
The Math got better: It stopped suggesting cooking times that were impossible (like 500 degrees for 2 hours).
Human Taste Test: When real humans compared the old robot recipes to the new ones, they preferred the new ones 62% of the time. The new recipes were actually usable!

The Big Takeaway

You don't need a bigger, more expensive robot to cook better. You just need to teach it a better way to learn. By changing the "homework grading system" (the loss function) to care about the structure and relationships of ingredients, rather than just the flow of words, the robot suddenly learned to cook.

In short: They taught the AI that a recipe isn't just a story; it's a precise blueprint. And if the blueprint is wrong, the house (or the dinner) collapses.

1. Problem Statement

The paper addresses the limitations of current Large Language Models (LLMs) and Small Language Models (SLMs) in structured recipe generation. While standard models can generate fluent text, they often fail to produce factually correct, numerically plausible, and procedurally executable recipes.

The Core Issue: Standard training relies on Cross-Entropy (CE) loss, which treats all tokens equally. This fails to account for the high asymmetry between "critical" tokens (ingredients, quantities, temperatures, times, core actions) and "low-impact" connective words.
Consequences: Models frequently omit essential ingredients, hallucinate quantities, or generate procedurally impossible steps (e.g., boiling water at 50°C), rendering the recipe unusable despite high linguistic fluency.
Metric Gap: Standard Natural Language Generation (NLG) metrics like ROUGE and BERTScore measure semantic similarity and fluency but fail to capture structural correctness, ingredient recall, or numerical accuracy.

2. Methodology

The authors propose a novel training framework that combines standard fine-tuning with composite loss functions designed to enforce structural and numerical constraints.

A. Dataset and Task

Dataset: A subset of 5,000 recipes from RECIPE-NLG (focusing on pasta, rice, and sandwiches) augmented with 235 manually curated cooking questions. These questions cover missing ingredient identification, substitution, scaling, and quantity/time reasoning to teach the model critical culinary relationships.
Task: Mapping a natural language prompt to a structured JSON output containing a list of ingredients ( $I$ ) and instruction steps ( $S$ ).
Preprocessing: All units were converted to the metric system to ensure numerical consistency.

B. Loss Functions

The study evaluates several loss functions, either alone or in combination with Cross-Entropy (CE):

Cross-Entropy (CE): The baseline.
Focal Loss: Down-weights easy examples to handle token frequency imbalance.
Dice Loss: Optimizes set-level overlap using a differentiable Dice coefficient to encourage correct token sets (effective for numerical precision).
Topological Loss (Main Contribution):
- Concept: Represents ingredient lists as point clouds in the embedding space.
- Mechanism:
  - For the predicted recipe, it generates soft probabilistic embeddings by applying softmax to output logits and computing a weighted average of the model's token embedding matrix.
  - For the ground truth, it uses standard embedding lookups.
  - It calculates the Sinkhorn Divergence (a differentiable approximation of Optimal Transport/Wasserstein distance) between the predicted and target point clouds.
- Goal: To minimize the geometric dissimilarity between the predicted and gold ingredient sets. This forces the model to generate ingredient lists that are structurally and semantically coherent in the embedding space, not just token-wise accurate.

C. Evaluation Metrics

Beyond standard ROUGE-1 and BERTScore, the authors introduce a recipe-specific metric suite:

Ingredient Recall (IR): Fraction of ground-truth ingredients generated.
Quantity Precision (QP): Accuracy of numerical quantities.
Action Precision (AP): Precision of key cooking verbs.
Edit Distances (AD, SD): Levenshtein distance for action sequences and full steps.
Time/Temperature Precision (TiP, TeP): Accuracy of duration and temperature values.

3. Key Contributions

Topological Loss: A novel loss function that utilizes Optimal Transport (Sinkhorn divergence) to align ingredient sets as point clouds in embedding space, explicitly encoding structural coherence beyond token-level matching.
Composite Objective Strategy: Demonstrates that combining Topological Loss with Dice Loss and CE creates a synergistic effect, balancing ingredient structure with numerical accuracy.
Specialized Evaluation Suite: Development of a comprehensive metric set specifically for structured recipe generation, moving beyond generic fluency metrics.
Empirical Validation: Extensive experiments across different model sizes (Qwen3-4B, Qwen3-14B, SmolLM3-3B, Qwen2.5-1.5B) and comparisons with commercial models (Gemini 2.0 Flash).

4. Results

Quantitative Performance

Topological Loss: Delivered the most consistent improvements over CE alone, significantly boosting Ingredient Recall (IR), Action Precision (AP), and Quantity Precision (QP). It achieved the lowest Action and Step edit distances, indicating superior procedural alignment.
Dice Loss: Excelled in Time and Temperature Precision, outperforming other methods in numerical accuracy.
Mixed Loss (Topo + Dice): The combined objective achieved the best overall performance, yielding the highest ROUGE-1, BERTScore, and QP, while matching the best edit distances. It demonstrated that Dice sharpens numerical/procedural accuracy while Topological loss enforces ingredient-level semantic structure.
Model Comparison: Fine-tuned SLMs (e.g., Qwen3-4B with Topo+Dice) significantly outperformed much larger pre-trained models (Qwen3-14B, Gemini 2.0) on recipe-specific metrics, proving that domain adaptation via custom losses is more effective than sheer parameter scale for this task.

Human Evaluation

Setup: 64 recipes evaluated by 3 expert annotators (hobbyist, pastry chef, baker).
Preference: The Topo+Dice model was preferred over the CE baseline in 62% of cases for overall quality (84% win rate excluding ties).
Error Reduction: The Topo+Dice model reduced generation errors by 67.5% compared to CE (7.8% error rate vs. 24.0%). Critical errors like step mismatches and hallucinations were virtually eliminated.

5. Significance and Conclusion

Efficiency: The proposed method improves structured generation in Small Language Models (SLMs) without increasing model size or inference-time complexity. The computational overhead is limited to training time (approx. +6.7%).
Paradigm Shift: The paper argues that for structured tasks, rethinking the loss function is more effective than relying solely on larger models or beam search. By treating ingredients as geometric point clouds, the model learns the "shape" of a valid recipe.
Practical Impact: The approach offers a pathway to generating safer, more reliable, and executable instructions for real-world applications (e.g., cooking assistants), addressing safety risks associated with hallucinated temperatures or missing ingredients.

Future Work: The authors suggest scaling to broader cuisines, incorporating explicit safety/nutrition validation, and refining the topological loss to handle individual ingredient parsing more explicitly.