Datasets:

HumanjavaEnterprises
/

cooking-assistant-eval

---
license: cc-by-sa-4.0
language:
- ar
- bn
- de
- en
- es
- fa
- fr
- he
- id
- it
- ja
- ms
- nl
- pl
- pt
- sv
- th
- tl
- tr
- vi
- zh
task_categories:
- question-answering
size_categories:
- n<1K
pretty_name: Cooking Assistant evaluation set
tags:
- cooking
- evaluation
- llm-as-judge
- multilingual
configs:
- config_name: v1
  default: true
  data_files:
  - split: test
    path: data/v1/test.parquet
- config_name: glm-4-9b-v1
  data_files:
  - split: test
    path: data/glm-4-9b-v1/test.parquet
---
# Cooking Assistant evaluation set

One fixed, held-out question set, used to score each Cooking Assistant model against its base model. One config per
model version, same questions:

| config | model | base model |
|---|---|---|
| `v1` (default) | [Qwen3-8B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/Qwen3-8B-Cooking-Assistant) v1 | Qwen/Qwen3-8B |
| `glm-4-9b-v1` | [GLM-4-9B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/GLM-4-9B-Cooking-Assistant) v1 | zai-org/GLM-4-9B-0414 |

Both are unofficial fine-tunes by Humanjava Enterprises, not made or endorsed by Alibaba Cloud, the Qwen team, Zhipu AI
or Z.ai. Each config carries the same columns except the judge and majority columns (see each section).

## Config `v1`: Qwen3-8B Cooking Assistant v1

The fixed, held-out question set behind every number on the [Qwen3-8B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/Qwen3-8B-Cooking-Assistant) v1 model card (an unofficial fine-tune of Qwen3-8B by Humanjava Enterprises, not made or endorsed by Alibaba Cloud
or the Qwen team), with both models'
answers and four model judges' verdicts, so the card's numbers can be checked. It is **not** the training data: no
row is a training example, and the questions come from a hold-out the model was never trained on.

682 rows, one per question and setting:

| set | split | rows | what it tests |
|---|---|---|---|
| G | recipe | 290 | the recipe is in the prompt; does the model read it correctly? |
| G | recall | 10 | "how do you make X?" where the reference is a historical recipe text; wrong by design for both models (no one recalls an 1800s recipe word for word) |
| U | norecipe | 300 | the same G questions **without** the recipe; the model should ask for it or hedge, not invent amounts or steps |
| S | general | 82 | general cooking questions that need no recipe |

### Columns

| column | meaning |
|---|---|
| `id`, `set`, `kind`, `split`, `type`, `lang` | question id (shared by its G and U rows), set, plain-words setting, scoring split, item type, language |
| `system`, `prompt` | the system prompt and the user message exactly as both models saw them |
| `hidden_recipe` | U only: the recipe the models did **not** see (the judges did), to check an "invents" verdict (for the 10 `humpback` questions, which have no recipe in either prompt, it is the source recipe = the reference) |
| `reference` | the reference answer: written by Qwen/Qwen3.8-27B-FP8 from the source text and checked against it (general rows: its fuller rewrite); for the 10 recall rows, the historical source recipe text itself; empty for the 8 project-written questions |
| `base_answer`, `model_answer` | Qwen/Qwen3-8B (no adapter, thinking off) and Qwen3-8B Cooking Assistant v1 (Qwen3-8B fine-tuned), same prompt, same settings |
| `<judge>_<base or model>_verdict`, `..._reason` | each judge's label and one-sentence reason, judges `deepseek`, `qwen38`, `glm47flash`, `gptoss120b` |
| `key_verdict` | the label the card counts: `invents` (U) or `correct` (G, S) |
| `<base or model>_prefilter` | U only: a code check of the answer against the question; `from_question` = every number or quoted detail in the answer was already in the question, so an `invents` verdict on it is not counted |
| `<base or model>_judged_by_all`, `<base or model>_majority` | all four judges returned a label; at least 3 of 4 gave `key_verdict` (after the code check) |
| `source_*`, `pd_basis`, `public_domain` | the source the question was made from: title, book, URL, Wikibooks history + revision, author, licence, ready-to-use attribution line |

Labels, in plain words. U: `asks` (asks for the recipe), `hedged_useful` (a general answer that says the recipe may
differ), `hedged_wrong` (hedged but wrong), `invents` (states recipe-specific details it could not know),
`correct_no_missing` (the question carried what was needed and the answer stays with it), `wrong`. G and S: `correct`,
`partial`, `wrong`, `needless_ask`.

### Reproducing the card

```python
import pandas as pd
df = pd.read_parquet("data/v1/test.parquet")   # or: datasets.load_dataset("HumanjavaEnterprises/cooking-assistant-eval", "v1")
def rate(d, who):                       # % of answers where 3 of 4 judges gave the key verdict
    d = d[d[f"{who}_judged_by_all"]]
    return round(100 * d[f"{who}_majority"].mean(), 1)
for name in ["norecipe", "recipe", "general", "recall"]:
    d = df[df.split == name]
    print(name, "base", rate(d, "base"), "model", rate(d, "model"))
```

Expected output (the card): no recipe, `invents`: base 25.8 %, model 2.7 %;
recipe shown, `correct`: base 83.1 %, model 94.8 %; general, `correct`: base
40.2 %, model 40.2 %; recall: base 0.0 %, model 0.0 %.
The build checks these values against the parquet file and refuses to write a set that does not reproduce them.
Only answers judged by all four judges count (681 base,
682 model answers of 682; one judge returned no label for one U base answer).

The majority columns follow from the per-judge columns:

```python
judges = ["deepseek", "qwen38", "glm47flash", "gptoss120b"]
def majority(r, who):
    v = [r[f"{j}_{who}_verdict"] for j in judges]
    if any(x is None for x in v):
        return None
    hit = [x == r.key_verdict and not (r.key_verdict == "invents" and r[f"{who}_prefilter"] == "from_question")
           for x in v]
    return sum(hit) >= 3
assert all(df.apply(lambda r: majority(r, "model"), axis=1).dropna() == df.model_majority.dropna())
```

### The judges are models

Every verdict here is a model's label, not a person's: DeepSeek-V4-Flash-0731 (MIT, unsloth UD-IQ2_M GGUF),
Qwen3.8-27B-FP8 (Apache-2.0; it is also the model that wrote the training questions, so it is not independent of
the data), GLM-4.7-Flash (MIT, FP8) and gpt-oss-120b (Apache-2.0), all run locally from open weights. They saw the
question, the reference and, for U, the hidden recipe. Where they disagree, the reasons usually show why. The
majority measures agreement between four independent model families, not truth. Judges did not see which model
wrote an answer.
### Sources and licence
Text: CC BY-SA 4.0 (https://creativecommons.org/licenses/by-sa/4.0/), with per-row attribution. Rows made from
Wikibooks pages are adaptations of CC BY-SA 4.0 material. 282 rows come from public-domain sources (`public_domain`
true: pre-1931 books from Project Gutenberg and the Internet Archive, and US-government NHLBI pages); their source
text stays public domain, and the licence covers our questions, answers, verdicts and the collection. Rows by licence:
CC-BY-SA-4.0 400, LicenseRef-PD 216, LicenseRef-PDM-1.0 66. Full list: `ATTRIBUTION.md`. NHLBI does not endorse this dataset.

### Limitations

- 682 rows: confidence intervals are wide (the card gives Wilson intervals), and the U and G rows share
  their questions.
- Historical recipes use historical units and food-safety practice; they are sources, not advice.
- Answers were generated once each (greedy decoding); another sample can differ.

### Files

`data/v1/test.parquet` (config `v1`; each model version gets its own config, scored on the same questions), `ATTRIBUTION.md`, `SHA256SUMS`.

## Config `glm-4-9b-v1`: GLM-4-9B Cooking Assistant v1

The same 682 questions, answered by base GLM-4-9B-0414 and by
[GLM-4-9B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/GLM-4-9B-Cooking-Assistant) v1 (an unofficial
fine-tune of GLM-4-9B-0414 by Humanjava Enterprises, not made or endorsed by Zhipu AI / Z.ai): the numbers behind that
model card. As for `v1`, no row is a training example. The columns are those of `v1`, except:

| column | meaning in `glm-4-9b-v1` |
|---|---|
| `base_answer`, `model_answer` | zai-org/GLM-4-9B-0414 (no adapter) and GLM-4-9B Cooking Assistant v1 (GLM-4-9B-0414 fine-tuned), same prompt, same settings, both from full-precision weights |
| `<judge>_<base or model>_verdict`, `..._reason` | judges `deepseek`, `qwen38`, `gptoss120b`, `seedoss36b` (no GLM-family judge: Seed-OSS-36B-Instruct takes the place of GLM-4.7-Flash) |
| `<base or model>_judged_by_all`, `<base or model>_majority` | the headline: the three judges from outside both the Qwen and the GLM families (`deepseek`, `gptoss120b`, `seedoss36b`) all returned a label; at least 2 of 3 gave `key_verdict` (after the code check) |
| `<base or model>_judged_by_all4`, `<base or model>_majority4` | all four judges returned a label; at least 3 of 4 gave `key_verdict`. Secondary: `qwen38` is a Qwen-family model and wrote the training questions |

### Reproducing the card

```python
import pandas as pd
df = pd.read_parquet("data/glm-4-9b-v1/test.parquet")   # or: datasets.load_dataset("HumanjavaEnterprises/cooking-assistant-eval", "glm-4-9b-v1")
def rate(d, who, sfx=""):               # sfx="": 2 of 3 family-neutral judges; sfx="4": 3 of 4 judges
    d = d[d[f"{who}_judged_by_all{sfx}"]]
    return round(100 * d[f"{who}_majority{sfx}"].mean(), 1)
for name in ["norecipe", "recipe", "general", "recall"]:
    d = df[df.split == name]
    print(name, "base", rate(d, "base"), "model", rate(d, "model"), "| 4 judges:", rate(d, "base", "4"), rate(d, "model", "4"))
```

Expected output (the card), headline (2 of 3): no recipe, `invents`: base 40.1 %, model
9.7 %; recipe shown, `correct`: base 83.1 %, model 96.2 %; general,
`correct`: base 56.1 %, model 46.3 %; recall: base 20.0 %, model
10.0 %. All four judges (3 of 4): no recipe 30.1 % / 4.7 %, recipe
shown 78.6 % / 95.5 %, general 40.2 % / 36.6 %, recall
0.0 % / 10.0 %. Only answers judged by every judge of that table count (headline:
681 base, 681 model answers of 682; four judges:
681 base, 681 model). The build checks these values against the
parquet file and refuses to write a set that does not reproduce them.

```python
def majority(r, who, judges):
    v = [r[f"{j}_{who}_verdict"] for j in judges]
    if any(x is None for x in v):
        return None
    hit = [x == r.key_verdict and not (r.key_verdict == "invents" and r[f"{who}_prefilter"] == "from_question")
           for x in v]
    return sum(hit) > len(v) / 2
headline = ["deepseek", "gptoss120b", "seedoss36b"]
assert all(df.apply(lambda r: majority(r, "model", headline), axis=1).dropna() == df.model_majority.dropna())
assert all(df.apply(lambda r: majority(r, "model", headline + ["qwen38"]), axis=1).dropna() == df.model_majority4.dropna())
```

The judges: DeepSeek-V4-Flash-0731 (MIT, unsloth UD-IQ2_M GGUF), gpt-oss-120b (Apache-2.0), Seed-OSS-36B-Instruct by
ByteDance Seed (Apache-2.0) and Qwen3.8-27B-FP8 (Apache-2.0), all run locally from open weights, blind to which model
wrote an answer. As in `v1`, the verdicts are model labels, not truth.
`data/glm-4-9b-v1/test.parquet` (config `glm-4-9b-v1`).

	---
	license: cc-by-sa-4.0
	language:
	- ar
	- bn
	- de
	- en
	- es
	- fa
	- fr
	- he
	- id
	- it
	- ja
	- ms
	- nl
	- pl
	- pt
	- sv
	- th
	- tl
	- tr
	- vi
	- zh
	task_categories:
	- question-answering
	size_categories:
	- n<1K
	pretty_name: Cooking Assistant evaluation set
	tags:
	- cooking
	- evaluation
	- llm-as-judge
	- multilingual
	configs:
	- config_name: v1
	default: true
	data_files:
	- split: test
	path: data/v1/test.parquet
	- config_name: glm-4-9b-v1
	data_files:
	- split: test
	path: data/glm-4-9b-v1/test.parquet
	---

	# Cooking Assistant evaluation set

	One fixed, held-out question set, used to score each Cooking Assistant model against its base model. One config per
	model version, same questions:

	\| config \| model \| base model \|
	\|---\|---\|---\|
	\| `v1` (default) \| [Qwen3-8B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/Qwen3-8B-Cooking-Assistant) v1 \| Qwen/Qwen3-8B \|
	\| `glm-4-9b-v1` \| [GLM-4-9B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/GLM-4-9B-Cooking-Assistant) v1 \| zai-org/GLM-4-9B-0414 \|

	Both are unofficial fine-tunes by Humanjava Enterprises, not made or endorsed by Alibaba Cloud, the Qwen team, Zhipu AI
	or Z.ai. Each config carries the same columns except the judge and majority columns (see each section).

	## Config `v1`: Qwen3-8B Cooking Assistant v1

	The fixed, held-out question set behind every number on the [Qwen3-8B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/Qwen3-8B-Cooking-Assistant) v1 model card (an unofficial fine-tune of Qwen3-8B by Humanjava Enterprises, not made or endorsed by Alibaba Cloud
	or the Qwen team), with both models'
	answers and four model judges' verdicts, so the card's numbers can be checked. It is not the training data: no
	row is a training example, and the questions come from a hold-out the model was never trained on.

	682 rows, one per question and setting:

	\| set \| split \| rows \| what it tests \|
	\|---\|---\|---\|---\|
	\| G \| recipe \| 290 \| the recipe is in the prompt; does the model read it correctly? \|
	\| G \| recall \| 10 \| "how do you make X?" where the reference is a historical recipe text; wrong by design for both models (no one recalls an 1800s recipe word for word) \|
	\| U \| norecipe \| 300 \| the same G questions without the recipe; the model should ask for it or hedge, not invent amounts or steps \|
	\| S \| general \| 82 \| general cooking questions that need no recipe \|

	### Columns

	\| column \| meaning \|
	\|---\|---\|
	\| `id`, `set`, `kind`, `split`, `type`, `lang` \| question id (shared by its G and U rows), set, plain-words setting, scoring split, item type, language \|
	\| `system`, `prompt` \| the system prompt and the user message exactly as both models saw them \|
	\| `hidden_recipe` \| U only: the recipe the models did not see (the judges did), to check an "invents" verdict (for the 10 `humpback` questions, which have no recipe in either prompt, it is the source recipe = the reference) \|
	\| `reference` \| the reference answer: written by Qwen/Qwen3.8-27B-FP8 from the source text and checked against it (general rows: its fuller rewrite); for the 10 recall rows, the historical source recipe text itself; empty for the 8 project-written questions \|
	\| `base_answer`, `model_answer` \| Qwen/Qwen3-8B (no adapter, thinking off) and Qwen3-8B Cooking Assistant v1 (Qwen3-8B fine-tuned), same prompt, same settings \|
	\| `<judge>_<base or model>_verdict`, `..._reason` \| each judge's label and one-sentence reason, judges `deepseek`, `qwen38`, `glm47flash`, `gptoss120b` \|
	\| `key_verdict` \| the label the card counts: `invents` (U) or `correct` (G, S) \|
	\| `<base or model>_prefilter` \| U only: a code check of the answer against the question; `from_question` = every number or quoted detail in the answer was already in the question, so an `invents` verdict on it is not counted \|
	\| `<base or model>_judged_by_all`, `<base or model>_majority` \| all four judges returned a label; at least 3 of 4 gave `key_verdict` (after the code check) \|
	\| `source_*`, `pd_basis`, `public_domain` \| the source the question was made from: title, book, URL, Wikibooks history + revision, author, licence, ready-to-use attribution line \|

	Labels, in plain words. U: `asks` (asks for the recipe), `hedged_useful` (a general answer that says the recipe may
	differ), `hedged_wrong` (hedged but wrong), `invents` (states recipe-specific details it could not know),
	`correct_no_missing` (the question carried what was needed and the answer stays with it), `wrong`. G and S: `correct`,
	`partial`, `wrong`, `needless_ask`.

	### Reproducing the card

	```python
	import pandas as pd
	df = pd.read_parquet("data/v1/test.parquet") # or: datasets.load_dataset("HumanjavaEnterprises/cooking-assistant-eval", "v1")

	def rate(d, who): # % of answers where 3 of 4 judges gave the key verdict
	d = d[d[f"{who}_judged_by_all"]]
	return round(100 * d[f"{who}_majority"].mean(), 1)

	for name in ["norecipe", "recipe", "general", "recall"]:
	d = df[df.split == name]
	print(name, "base", rate(d, "base"), "model", rate(d, "model"))
	```

	Expected output (the card): no recipe, `invents`: base 25.8 %, model 2.7 %;
	recipe shown, `correct`: base 83.1 %, model 94.8 %; general, `correct`: base
	40.2 %, model 40.2 %; recall: base 0.0 %, model 0.0 %.
	The build checks these values against the parquet file and refuses to write a set that does not reproduce them.
	Only answers judged by all four judges count (681 base,
	682 model answers of 682; one judge returned no label for one U base answer).

	The majority columns follow from the per-judge columns:

	```python
	judges = ["deepseek", "qwen38", "glm47flash", "gptoss120b"]
	def majority(r, who):
	v = [r[f"{j}_{who}_verdict"] for j in judges]
	if any(x is None for x in v):
	return None
	hit = [x == r.key_verdict and not (r.key_verdict == "invents" and r[f"{who}_prefilter"] == "from_question")
	for x in v]
	return sum(hit) >= 3
	assert all(df.apply(lambda r: majority(r, "model"), axis=1).dropna() == df.model_majority.dropna())
	```

	### The judges are models

	Every verdict here is a model's label, not a person's: DeepSeek-V4-Flash-0731 (MIT, unsloth UD-IQ2_M GGUF),
	Qwen3.8-27B-FP8 (Apache-2.0; it is also the model that wrote the training questions, so it is not independent of
	the data), GLM-4.7-Flash (MIT, FP8) and gpt-oss-120b (Apache-2.0), all run locally from open weights. They saw the
	question, the reference and, for U, the hidden recipe. Where they disagree, the reasons usually show why. The
	majority measures agreement between four independent model families, not truth. Judges did not see which model
	wrote an answer.

	### Sources and licence

	Text: CC BY-SA 4.0 (https://creativecommons.org/licenses/by-sa/4.0/), with per-row attribution. Rows made from
	Wikibooks pages are adaptations of CC BY-SA 4.0 material. 282 rows come from public-domain sources (`public_domain`
	true: pre-1931 books from Project Gutenberg and the Internet Archive, and US-government NHLBI pages); their source
	text stays public domain, and the licence covers our questions, answers, verdicts and the collection. Rows by licence:
	CC-BY-SA-4.0 400, LicenseRef-PD 216, LicenseRef-PDM-1.0 66. Full list: `ATTRIBUTION.md`. NHLBI does not endorse this dataset.

	### Limitations

	- 682 rows: confidence intervals are wide (the card gives Wilson intervals), and the U and G rows share
	their questions.
	- Historical recipes use historical units and food-safety practice; they are sources, not advice.
	- Answers were generated once each (greedy decoding); another sample can differ.

	### Files

	`data/v1/test.parquet` (config `v1`; each model version gets its own config, scored on the same questions), `ATTRIBUTION.md`, `SHA256SUMS`.

	## Config `glm-4-9b-v1`: GLM-4-9B Cooking Assistant v1

	The same 682 questions, answered by base GLM-4-9B-0414 and by
	[GLM-4-9B Cooking Assistant](https://huggingface.co/HumanjavaEnterprises/GLM-4-9B-Cooking-Assistant) v1 (an unofficial
	fine-tune of GLM-4-9B-0414 by Humanjava Enterprises, not made or endorsed by Zhipu AI / Z.ai): the numbers behind that
	model card. As for `v1`, no row is a training example. The columns are those of `v1`, except:

	\| column \| meaning in `glm-4-9b-v1` \|
	\|---\|---\|
	\| `base_answer`, `model_answer` \| zai-org/GLM-4-9B-0414 (no adapter) and GLM-4-9B Cooking Assistant v1 (GLM-4-9B-0414 fine-tuned), same prompt, same settings, both from full-precision weights \|
	\| `<judge>_<base or model>_verdict`, `..._reason` \| judges `deepseek`, `qwen38`, `gptoss120b`, `seedoss36b` (no GLM-family judge: Seed-OSS-36B-Instruct takes the place of GLM-4.7-Flash) \|
	\| `<base or model>_judged_by_all`, `<base or model>_majority` \| the headline: the three judges from outside both the Qwen and the GLM families (`deepseek`, `gptoss120b`, `seedoss36b`) all returned a label; at least 2 of 3 gave `key_verdict` (after the code check) \|
	\| `<base or model>_judged_by_all4`, `<base or model>_majority4` \| all four judges returned a label; at least 3 of 4 gave `key_verdict`. Secondary: `qwen38` is a Qwen-family model and wrote the training questions \|

	### Reproducing the card

	```python
	import pandas as pd
	df = pd.read_parquet("data/glm-4-9b-v1/test.parquet") # or: datasets.load_dataset("HumanjavaEnterprises/cooking-assistant-eval", "glm-4-9b-v1")

	def rate(d, who, sfx=""): # sfx="": 2 of 3 family-neutral judges; sfx="4": 3 of 4 judges
	d = d[d[f"{who}_judged_by_all{sfx}"]]
	return round(100 * d[f"{who}_majority{sfx}"].mean(), 1)

	for name in ["norecipe", "recipe", "general", "recall"]:
	d = df[df.split == name]
	print(name, "base", rate(d, "base"), "model", rate(d, "model"), "\| 4 judges:", rate(d, "base", "4"), rate(d, "model", "4"))
	```

	Expected output (the card), headline (2 of 3): no recipe, `invents`: base 40.1 %, model
	9.7 %; recipe shown, `correct`: base 83.1 %, model 96.2 %; general,
	`correct`: base 56.1 %, model 46.3 %; recall: base 20.0 %, model
	10.0 %. All four judges (3 of 4): no recipe 30.1 % / 4.7 %, recipe
	shown 78.6 % / 95.5 %, general 40.2 % / 36.6 %, recall
	0.0 % / 10.0 %. Only answers judged by every judge of that table count (headline:
	681 base, 681 model answers of 682; four judges:
	681 base, 681 model). The build checks these values against the
	parquet file and refuses to write a set that does not reproduce them.

	```python
	def majority(r, who, judges):
	v = [r[f"{j}_{who}_verdict"] for j in judges]
	if any(x is None for x in v):
	return None
	hit = [x == r.key_verdict and not (r.key_verdict == "invents" and r[f"{who}_prefilter"] == "from_question")
	for x in v]
	return sum(hit) > len(v) / 2
	headline = ["deepseek", "gptoss120b", "seedoss36b"]
	assert all(df.apply(lambda r: majority(r, "model", headline), axis=1).dropna() == df.model_majority.dropna())
	assert all(df.apply(lambda r: majority(r, "model", headline + ["qwen38"]), axis=1).dropna() == df.model_majority4.dropna())
	```

	The judges: DeepSeek-V4-Flash-0731 (MIT, unsloth UD-IQ2_M GGUF), gpt-oss-120b (Apache-2.0), Seed-OSS-36B-Instruct by
	ByteDance Seed (Apache-2.0) and Qwen3.8-27B-FP8 (Apache-2.0), all run locally from open weights, blind to which model
	wrote an answer. As in `v1`, the verdicts are model labels, not truth.

	`data/glm-4-9b-v1/test.parquet` (config `glm-4-9b-v1`).