Refining the Recipe: Improving CBR Retrieval through FCA-based Ontology Enrichment

TL;DR

Case-Based Reasoning (CBR) platforms like TAAABLE often rely on ontologies to find similar cases when an exact match isn't available. However, "coarse" ontologies lead to bad substitutions—like replacing Mozzarella with Mascarpone in a lasagna recipe. This paper introduces a technique using Formal Concept Analysis (FCA) to automatically "tighten" ontologies by mining thousands of recipe texts for ingredient properties, leading to higher-quality retrieval and fewer adaptation failures.

Problem & Motivation: The "Flat Ontology" Trap

In CBR, the retrieval of a source case is guided by an ontology. If a user wants a recipe with "Mascarpone" but none exists, the system generalizes "Mascarpone" to "Fresh Cheese" and looks for other siblings under that category.

The fatal flaw? In a standard hierarchy, Mozzarella and Ricotta are both just "Fresh Cheeses." If the original recipe calls for slicing the cheese, substituting Ricotta for Mozzarella works, but substituting Mascarpone—a creamy spread—will lead to a culinary disaster. The system lacks the "knowledge" that some fresh cheeses are sliceable while others are beatable.

The authors' insight is that by mining cooking actions (functional properties) from external text, they can create a more nuanced hierarchy that clusters ingredients not just by "what they are" but by "how they behave."

Methodology: Formal Concept Analysis (FCA)

The researchers used a four-step pipeline to transform a basic taxonomy into a refined, action-aware ontology.

1. Data Mining for Properties

They analyzed over 73,000 recipes to extract pairs of (ingredient, action). For example, finding that "Ricotta" is frequently associated with the action "mix," whereas "Mozzarella" is linked to "slice" or "grate."

2. Formal Context Building

They created a binary context table where objects (ingredients) are rows and attributes (cooking actions + original categories) are columns.

3. Lattice Generation

Using FCA, they generated a Concept Lattice. Each node in this lattice represents a "formal concept"—a group of ingredients that share a specific set of actions. This lattice naturally discovers "structuring concepts" that don't exist in the original ontology.

4. Ontology Reification

These new concepts are then injected back into the TAAABLE system. For example, a new class is created: FreshCheese#BeatAble#MeltAble#MixAble. This class acts as a filter during retrieval, ensuring that only ingredients belonging to this specific functional group are considered as valid substitutes.

Experiments & Results: Eliminating "Uncookable" Recipes

The team compared the baseline system (TAAABLE0) with the refined version (TAAABLE1).

When queried for a recipe with "Tomato" and "Mascarpone," the baseline system suggested substitutions that involved "grating" or "slicing" Mascarpone—clear failures. In contrast, the refined system narrowed the results to only include recipes where the substituted ingredient (like Ricotta) shared the "mixable" or "beatable" properties of Mascarpone.

Key Outcome:

• Precision vs. Recall: While TAAABLE1 returned fewer recipes (4 vs 8), the quality was significantly higher.
• Failure Rate: 6 out of 11 substitutions suggested by the baseline failed human evaluation of "cookability." TAAABLE1 had zero clear failures.

Critical Analysis & Conclusion

This work demonstrates that ontologies are not static; they can and should be evolved through data mining. By integrating Formal Concept Analysis, the authors provide a mathematical framework to bridge the gap between "Taxonomic Knowledge" (is-a) and "Procedural Knowledge" (can-do).

Takeaway: Effective retrieval in complex domains requires more than just semantic similarity; it requires functional compatibility. This approach is highly extensible to other domains like medicine (drug substitution) or software engineering (component replacement).

Future Work: The authors note that the set of properties used for refinement is currently manually narrowed. A future challenge is to automate property selection to account for shifting contexts—where an ingredient might be "similar" to one thing when baking, but "similar" to another when frying.