Uploading TomaMMU dataset with updated README.md and sample images

README.md

@@ -1,102 +1,133 @@
 ---
-license: cc-by-nc-4.0
+pretty_name: TomaMMU
+license: other
 task_categories:
-- visual-question-answering
 - image-text-to-text
-tags:
-- agriculture
-- plant-pathology
-- tomato
-- vqa
-- vision-language
-pretty_name: TomaMMU
+- visual-question-answering
+size_categories:
+- 100K<n<1M
+source_datasets:
+- LeafNet
+- TOM2024
+- In-house tomato leaf images (TomaMMU authors)
 configs:
-- config_name: train
+- config_name: default
   data_files:
   - split: train
     path: train-0000-of-0001.parquet
 dataset_info:
-  config_name: train
+  features:
+  - name: images
+    list:
+    - name: bytes
+      dtype: 'null'
+    - name: path
+      dtype: string
+  - name: id
+    dtype: string
+  - name: messages
+    list:
+    - name: role
+      dtype: string
+    - name: content
+      list:
+      - name: type
+        dtype: string
+      - name: text
+        dtype: string
+  - name: raw_metadata
+    dtype: string
   splits:
   - name: train
+    num_bytes: 334409642
     num_examples: 213119
-size_categories:
-- 100K<n<1M
+  download_size: 334409642
+  dataset_size: 334409642
 ---
 
 # TomaMMU
 
-TomaMMU is a tomato leaf disease VQA dataset built by researchers at FPT University (Vietnam) and Korea University. The motivation behind it is pretty simple: most tomato disease models are trained and tested on clean, lab-quality images, but accuracy falls off a cliff (30-40%) once you point them at a real field photo with messy backgrounds and inconsistent lighting. TomaMMU tries to close that gap by pairing field- and lab-collected photos with human-annotated questions that go well beyond "sick or healthy" — asking models to identify the crop, count leaves, name the pathogen, and even give the scientific name of the disease.
+![TomaMMU sample images](static/TomaMMU_sample.webp)
 
-There are two papers behind this work. The first introduces the dataset and a benchmark (TomaBench) for evaluating VLMs on it. The second, SOLAR, builds a fine-tuned model on top of it.
+TomaMMU is a visual question answering dataset about tomato leaf diseases. It has 213,119 question and answer pairs over 28,808 leaf images in 15 categories (14 diseases and healthy), covering 25 disease symptoms. The images come from LeafNet, TOM2024 and the authors' own collections, and include both field and lab photos. Human annotators reviewed and finalized every question and answer.
 
-- [TomaMMU: A Comprehensive Multimodal Understanding Benchmark for Tomato Leaf Diseases](https://doi.org/10.48550/arXiv.2608.08727) — Truong, Quoc, Quach (arXiv:2608.08727)
-- [A Multi-Modal Generative Model for Tomato Disease Leaves Understanding](https://doi.org/10.48550/arXiv.2609.19555) — Quoc, Tran, Truong, Quach (arXiv:2609.19555) — the SOLAR model paper, trained on this dataset
-- Original repository: [huggingface.co/datasets/enalis/TomaMMU](https://huggingface.co/datasets/enalis/TomaMMU)
+The questions cover 7 tasks at 3 levels. The authors tested 14 vision-language models; the best zero-shot model, Gemini 2.0 Flash, averaged 70.3% on the multiple-choice questions. Their fine-tuned model, TomaLLaVA, reached 96.09%.
 
-## What's in the papers
+A second paper from the same group trains SOLAR, a model for tomato leaf question answering, using this data.
 
-The images come from LeafNet and TOM2024, mixing field shots with lab photos, and cover 15 disease categories (14 diseases plus healthy) with 25 distinct symptoms. Every question was human-annotated rather than machine-generated, which the authors call out as a deliberate contrast to lab-only benchmarks like PlantVillage.
+- Paper: [TomaMMU: A Comprehensive Multimodal Understanding Benchmark for Tomato Leaf Diseases](https://arxiv.org/abs/2608.08727)
+- Related paper: [A Multi-Modal Generative Model for Tomato Disease Leaves Understanding](https://arxiv.org/abs/2609.19555)
+- Original dataset: [enalis/TomaMMU](https://huggingface.co/datasets/enalis/TomaMMU)
+- License: the authors do not state a license.
 
-Questions fall into seven types, organized into three difficulty tiers:
+## Tasks
 
-| Level | Task types |
-|---|---|
-| 1: Basic Perception | HDC (Healthy-Diseased Classification), LC (Leaf Count), CSI (Crop Species Identification) |
-| 2: Pathology Understanding | SI (Symptom Identification), PC (Pathogen Classification) |
-| 3: Expert Diagnosis | DC (Disease Classification), SNC (Scientific Name Classification) |
+| Level | Task | `question_type` |
+|---|---|---|
+| 1. Basic Perception | Healthy-Diseased Classification | `HDC` |
+| 1. Basic Perception | Leaf Classification | `LC` |
+| 1. Basic Perception | Crop Species Identification | `CSI` |
+| 2. Pathology Understanding | Symptom Identification | `SI` |
+| 2. Pathology Understanding | Pathogen Classification | `PC` |
+| 3. Expert Diagnosis | Disease Classification | `DC` |
+| 3. Expert Diagnosis | Scientific Name Classification | `SNC` |
 
-The first paper's own eval setup (TomaBench) splits things into 124,367 pairs for fine-tuning plus a held-out set of 42,626 multiple-choice and 37,816 open-ended questions. They benchmarked a wide range of models — Gemini 2.0 Flash, InternVL3, Qwen2.5/3, Gemma4, SmolVLM2, LLaVA-1.5, LFM2.5-VL, plus CLIP-family models (CLIP-ViT-L-14, SigLIP2, BioCLIP, SCOLD). The best zero-shot model only hit 61.3% MCQ accuracy, and open-ended answers were a lot worse (~2.5/5 on GPT-graded scoring across the board). Fine-tuning closes most of that gap: their TomaLLaVA model reached 96.09% on the MCQ set.
+All rows are multiple-choice, with 2 or 4 options.
 
-The second paper (SOLAR) picks up from there and builds an actual diagnostic model rather than just benchmarking existing ones — a vision encoder (SCOLD) feeding into a sparse mixture-of-experts layer that routes attention based on the question, then an LFM-VL 2.5 decoder for generating the answer. It hits 97.68% on TomaMMU and holds up reasonably (69% average) across three other external tomato-disease datasets it wasn't trained on. Interestingly, symptom identification is still the weakest link (7.8% error rate) and mistakes there tend to cascade into wrong disease/pathogen answers downstream — worth keeping in mind if you're using this data to train or evaluate something similar.
+## Structure
 
-Neither paper nor the original dataset card lists a license, so this repo's card leaves it as unspecified rather than guessing.
+```
+train-0000-of-0001.parquet
+images/
+  image-train-000-of-001.zip
+  path_to_shard.parquet
+```
 
-## What's standardized here
+Each row has:
+
+- `images`: list with one `{"bytes": null, "path": <sha256>}`. The path is the SHA256 of the image bytes and points into a zip shard through `images/path_to_shard.parquet`.
+- `id`: `tomammu_train_<counter>`, for example `tomammu_train_0`.
+- `messages`: one user turn (image, then question with options) and one assistant turn (answer).
+- `raw_metadata`: JSON string with `image_path`, `question_id` and `question_type`.
+
+Example:
+
+```json
+{
+  "images": [{"bytes": null, "path": "4a31a8b625ce2e767cd4ed8e54f9b7d0bf0e9fb843e16050b7679a6bc8f293c8"}],
+  "id": "tomammu_train_0",
+  "messages": [
+    {"role": "user", "content": [
+      {"type": "image", "text": null},
+      {"type": "text", "text": "Does the image show a diseased plant?\nA. Disease\nB. Healthy"}
+    ]},
+    {"role": "assistant", "content": [{"type": "text", "text": "A. Disease"}]}
+  ],
+  "raw_metadata": "{\"image_path\": \"val/Tomato___Bacterial_Floundering/1005963105_1668687142186_640x480.jpg\", \"question_id\": \"hdc::00001\", \"question_type\": \"HDC\"}"
+}
+```
 
-This repo has the full 213,119-pair corpus in a single `train` config — it doesn't reproduce the paper's own 60/20/20 train/eval split, since the source CSV has no split column to begin with.
-| Config | Rows (QA pairs) | Unique images | Image data |
-|---|---|---|---|
-| train | 213,119 | 28,112 | 0.31GB (1 shard) |
+### Changes from the original data
 
-One thing worth flagging: the source `Tomato.csv` lists 36,993 distinct `image_path` strings, but a good chunk of those are just case differences (`Tomato___Bacterial_Floundering` vs `Tomato___Bacterial_floundering`) that point at the same file on a case-insensitive filesystem. Rather than dedup by path string, images here are keyed by a SHA256 hash of their actual bytes, which sidesteps the casing issue entirely. That's how 36,993 path strings end up as 28,112 unique stored images, matching the paper's reported 28,808 real files once you account for the hash collapsing true duplicates.
+- Built from `Tomato.csv`, which has one row per question. The source has no split column, so all rows are in one `train` split. The paper's TomaBench split is not reproduced.
+- Options come from the `A` to `D` columns and are added to the question as lines like `A. text`. Empty options are left out, so some questions show only A and B. Spaces around option text are trimmed.
+- Answers combine the answer letter and the `correct_text` column, for example `A. Disease`.
+- `raw_metadata` keeps `image_path`, `question_id` and `question_type`. The question, options and answer are already in `messages`.
+- The CSV has 36,993 different image path strings, but many differ only in letter case and point to the same file. Images are stored once, deduplicated by SHA256, which leaves 28,112 unique images. Only images used by the rows are packed.
 
-Question type breakdown:
-| Question type | Options
-|---|---
-| SI (Symptom Identification) | 4
-| HDC (Healthy-Diseased Classification) | 2
-| CSI (Crop Species Identification) | 4
-| LC (Leaf Count) | 2 | 28,799 |
-| DC (Disease Classification) | 4
-| PC (Pathogen Classification) | 4
-| SNC (Scientific Name Classification) | 4
+## Usage
 
-All seven types are multiple-choice — there's no open-ended detection-style task in this corpus (unlike the paper's own OEQ eval set, which isn't part of what's standardized here).
+```python
+from agml import loadImageTextToTextDataset
 
-## Layout
+dataset = loadImageTextToTextDataset("Project-AgML/TomaMMU")
 
+sample = dataset["train"][0]
+sample["images"]    # list of PIL images
+sample["messages"]
 ```
-train-0000-of-0001.parquet          # metadata rows
-images/
-  image-train-000-of-001.zip        # image shard (ZIP_STORED, uncompressed)
-  path_to_shard.parquet             # maps image SHA256 hash -> shard_file
-```
-
-Images sit uncompressed inside zip shards, keyed by hash, capped at 5GB per shard (this dataset only needed one).
 
-## Schema
-
-| Column | Type | Description |
-|---|---|---|
-| `images` | `list<struct<bytes, path>>` | `bytes` is `null`; `path` is the SHA256 hash, looked up in `images/path_to_shard.parquet` |
-| `id` | `string` | `tomammu_train_<n>` |
-| `messages` | chat-style list | user turn is the image plus the question, with whichever lettered options are actually present in the source (some rows only have A/B); assistant turn combines the answer's letter with its text, e.g. `"B. Bacterial Floundering"`, rather than just the bare text |
-| `raw_metadata` | JSON string | `image_path` (the original source path), `question_id`, `question_type` |
-
-Each row is one image-question pair, so the same image shows up across as many as seven rows.
-
-## Citations
+## Citation
 
 ```bibtex
 @article{truong2026tomammu,
@@ -114,6 +145,4 @@ Each row is one image-question pair, so the same image shows up across as many a
 }
 ```
 
----
-
-This dataset is indexed and structured on https://project-agml.github.io/ as part of the AgML python library. This dataset was reformatted from its original format to match HuggingFace's Imagefolder standards but requires an external module (agml) that processes and returns a HF Dataset object faster than HF module functions.
+This dataset is indexed and structured on https://project-agml.github.io/ as part of Project AgML @ UC Davis. This dataset was reformatted from its original format to match HuggingFace's Imagefolder standards but requires an external module (agml) that processes and returns a HF Dataset object faster than HF module functions.