mashi6n/nhkrecipe-100-anno-1

Dataset Card for NHKRecipe-Anno-100

This dataset provides ingredient state annotations for 100 recipes from the NHKRecipe dataset.

Dataset Description

This dataset provides ingredient state annotations for 100 recipes extracted from NHK-supervised recipes (NHKRecipe).

An ingredient state refers to the condition of an ingredient as it changes throughout the cooking process, and is described in natural language for all ingredients present at the end of each cooking step.

The annotations also include transitions between ingredient states, allowing the tracking of interactions such as splitting and mixing of ingredients.

• Paper: arXiv
• Language: Japanese
• License: CC BY-SA 4.0

Dataset Sources

The recipes targeted for annotation were collected from the NHK “Minna no Kyou no Ryouri” recipe website. Note that this dataset contains only the annotations and does not include most parts of the original recipes (such as the cooking procedures). To reconstruct the original recipes, please use the recipe download script provided later in this documentation.

• Recipe Site: https://www.kyounoryouri.jp/
• Scraping Script: https://github.com/mashi6n/kyounoryouri-tools

Dataset Structure

The dataset in the main branch contains 60 entries in the train split and 40 entries in the test split. The data in the train split was used for training in the paper, while the data in the test split was used for performance evaluation based on the annotations.

For more details, please refer to the paper.

Data Schema

The schema of each entry in the dataset is described using practical Python code based on the Pydantic module, as shown below.

from uuid import UUID

from pydantic import BaseModel, Field

class SourceIngredientRelation(BaseModel):
    # This class represents how much of which ingredient is used to produce another ingredient.
    id: UUID  # UUID of the source ingredient (State). Note that this ID is not automatically generated.
    quantity: str  # Amount of the source ingredient used

class State(BaseModel):
    # This class represents an ingredient or the state of an ingredient.
    id: UUID   # Unique UUID. Automatically assigned.
    name: str  # Name of this ingredient
    quantity: str = Field(default="")     # Quantity of this ingredient
    description: str = Field(default="")  # Description of this ingredient
    resulting_from: int  # Indicates which step resulted in this ingredient. For example, resulting_from=2 means this ingredient was produced after step 2.
    source_ingr_list: list[SourceIngredientRelation]  # References to the ingredients that were used to produce this ingredient

class WorldState(BaseModel):
    # This class represents the set of ingredients that exist after each step.
    step_after: int  # For example, step_after=3 means this ingredient set exists after step 3.
    state_list: list[State]  # Set of ingredients that exist

class StateGraph(BaseModel):
    # This class corresponds to one recipe and holds the WorldState after each cooking step.
    id: str  # Recipe ID. Matches the ID assigned to the recipe data created by a separate script. Note that this is a string, not a UUID.
    worldstate_list: list[WorldState]  # List of world states after each cooking step, in order.

Each entry in the dataset can be parsed as a StateGraph. By using this code, the dataset can be handled in a type-safe manner. While Pydantic is used here, the schema could also be defined using alternatives such as TypedDict.

Citation

BibTeX:

@inproceedings{toyooka2025AHighlyClean
  author = {Toyooka, Mashiro and Aizawa, Kiyoharu and Yamakata, Yoko},
  title = {A Highly Clean Recipe Dataset with Ingredient States Annotation for State Probing Task},
  year = {2025},
  isbn = {9798400720352},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3746027.3755771},
  doi = {10.1145/3746027.3755771},
  abstract = {Large Language Models (LLMs) are trained on a vast amount of procedural texts, but they do not directly observe real-world phenomena. In the context of cooking recipes, this poses a challenge, as intermediate states of ingredients are often omitted, making it difficult for models to track ingredient states and understand recipes accurately. In this paper, we apply state probing, a method for evaluating a language model's understanding of the world, to the domain of cooking. We propose a new task and dataset for evaluating how well LLMs can recognize intermediate ingredient states during cooking procedures. We first construct a new Japanese recipe dataset with clear and accurate annotations of ingredient state changes, collected from well-structured and controlled recipe texts. Using this dataset, we design three novel tasks to evaluate whether LLMs can track ingredient state transitions and identify ingredients present at intermediate steps. Our experiments with widely used LLMs, such as Llama3.1-70B and Qwen2.5-72B, show that learning ingredient state knowledge improves their understanding of cooking processes, achieving performance comparable to commercial LLMs. The dataset are publicly available at: https://huggingface.co/datasets/mashi6n/nhkrecipe-100-anno-1.},
  booktitle = {Proceedings of the 33rd ACM International Conference on Multimedia},
  pages = {748–756},
  numpages = {9},
  keywords = {cooking recipe, large language models (llms), large multimodal models (lmms), procedural text understanding, state probing},
  location = {Dublin, Ireland},
  series = {MM '25}
}