This model is a RoBERTa-base token-classification model trained on ReciFineGold for recipe-focused Named Entity Recognition (NER) using a Knowledge-Augmented & Entity Type-Specific (KAES) formulation.

In KAES, the model extracts one entity type at a time by prepending a curated knowledge context (here: a natural-language definition prompt) to the input recipe sentence. This encourages the encoder to focus on spans relevant to the requested entity type, rather than relying only on the sentence’s internal context.

What this checkpoint is

Backbone: RoBERTa-base
Task: Token classification (BIO-style tagging)
Formulation: Knowledge-Augmented + Entity Type-Specific (single entity type per run)
Knowledge type: Definition prompt (e.g., “A STATE describes the physical condition of an ingredient.”)

How to use

The ReciFine library provides a lightweight inference wrapper (ReciFineNER) that handles the KAES prompting and decoding.

python

# Install ReciFine (see repo for latest install instructions)
pip install https://github.com/nuhu-ibrahim/ReciFine/archive/refs/tags/V1.zip

from recifine.inferencing.inference import ReciFineNER

ner = ReciFineNER.from_pretrained(
    model="reciperoberta",
    task_formulation="knowledge_guided",
    knowledge_type="definition",
)

text = "Add 2 cups of chopped onions and fry until golden."
prediction = ner.process_text(text, entity_type="QUANTITY")

print(prediction)

Quick links (documentation + notebook)

ReciFine library (recommended): training scripts, inference wrappers, and full documentation
https://github.com/nuhu-ibrahim/ReciFine/tree/main
Colab (end-to-end usage demo):
https://colab.research.google.com/drive/1CatH2YOhnOWf-VglprEgxONWRkrXRBXo?usp=sharing&authuser=1

Intended use

Use this model to extract fine-grained recipe entities from procedural recipe text (e.g., instructions), including ingredients, tools, quantities, durations, actions, and state descriptors.

Typical applications:

Structured parsing of recipe steps
Ingredient and action extraction for downstream cooking assistants
Data normalisation and indexing for recipe search
Entity-aware prompting and evaluation pipelines for recipe generation

Knowledge-Augmented & Entity Type-Specific classification (KAES)

Unlike traditional token classification pipelines that rely solely on internal sentence context, we adopt a KA formulation that prepends curated knowledge contexts to the input to guide the model toward the entities of the relevant entity type.

Let the token sequence for a recipe sentence be denoted as:

x = {x1, x2, ..., xn}

and let the knowledge context associated with a particular entity type Ej be represented as a natural language context:

pj = {p1(j), ..., pm(j)}

Each context pj belongs to one of five types (question type, definition type, examples type, entity type name type, and combined type).

We construct the augmented input to the encoder as:

x̃ = {[CLS], pj, [SEP], x1, ..., xn, [SEP]}

where m is the length of the context and n is the length of the recipe tokens. The full sequence x̃ is passed through a transformer encoder (e.g., BERT or RoBERTa), and a feedforward classification layer predicts BIO tags for each token.

This setup introduces a form of entity type conditioning, enabling the model to modulate its attention and token representations based on the target entity type. Unlike multi-entity type classification with shared label spaces, our formulation uses a single encoder across all entity types but treats each classification task independently.

Supported knowledge types (KAES)

Entity Type Name (entity_type): A plain directive that names the entity type, e.g., FOOD STATE.
Question Prompt (question): A natural question about the entity type, e.g., Which words describe the state of the food?.
Example Type (example): A list of entity examples, e.g., melted, frozen, chopped.
Definitional Sentence (definition): A brief definition of the entity type, e.g., A STATE describes the physical condition of an ingredient.
Combined Type (all): A concatenation of all the above, providing the richest context.

Supported entity types

Entity Type	Definition
`FOOD`	Edible items, including both raw ingredients and intermediate products
`TOOL`	Cooking tools such as knives, bowls, pans
`DURATION`	Time durations in cooking (e.g., 20 minutes)
`QUANTITY`	Quantities associated with ingredients
`ACTION_BY_CHEF`	Verbs for deliberate cook actions (e.g., bring in “Bring the mixture to a boil”)
`ACTION_BY_CHEF_DISCONTINUOUS`	Non-contiguous parts of compound chef actions (e.g., to a boil)
`ACTION_BY_FOOD`	Verbs where food is the agent (e.g., melt, boil)
`ACTION_BY_TOOL`	Verbs denoting tool actions (e.g., grind, beat)
`FOOD_STATE`	Descriptions of food’s state (e.g., chopped, soft)
`TOOL_STATE`	Descriptions of tool readiness (e.g., preheated, greased, covered)

Research Papers

Knowledge-Augmented and Entity Type-Specific Token Classification

The knowledge-augmented and entity type-specific token classification model architecture is described in the paper Knowledge Augmentation Enhances Token Classification for Recipe Understanding.

bibtex

@inproceedings{
  title     = {Knowledge Augmentation Enhances Token Classification for Recipe Understanding},
  author    = {Ibrahim, Nuhu and Stevens, Robert and Batista-Navarro, Riza},
  booktitle = {EACL},
  year      = {2026}
}

ReciFine Datasets and Controllable Recipe Generation

The ReciFine, ReciFineGold and ReciFineGen datasets are described in the paper ReciFine: Finely Annotated Recipe Dataset for Controllable Recipe Generation.