Upload folder using huggingface_hub

README.md

@@ -0,0 +1,137 @@
+---
+license: mit
+task_categories:
+- visual-question-answering
+language:
+- en
+tags:
+- multimodal
+pretty_name: MolParse
+size_categories:
+- 1K<n<10K
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: data/test.parquet
+---
+
+# MolParse Bench
+
+<center><h1>MolParse</h1></center>
+
+<p align="center">
+  <img src="./assets/pipeline.png" alt="MolParse" style="display: block; margin: auto; max-width: 70%;">
+</p>
+
+<p align="center">
+  | <a href="https://huggingface.co/datasets/InnovatorLab/MolParse"><b>HuggingFace</b></a> |
+  <a href="https://github.com/InnovatorLab/MolParse"><b>Code</b></a> |
+</p>
+
+---
+
+## 🔥 Latest News
+
+- **[2026/01]** MolParse v1.0 is officially released.
+
+---
+
+## Overview
+
+**MolParse** is a large-scale multimodal dataset for **optical chemical structure parsing**, designed to evaluate and train models that convert **molecular structure images** into **structured chemical representations**.
+
+The dataset focuses on realistic chemical diagrams commonly found in scientific literature and patents, emphasizing robustness to visual noise, diverse drawing styles, and complex molecular layouts. MolParse supports tasks that require precise visual perception and structured chemical understanding, rather than simple text recognition.
+
+---
+
+## Benchmark Scope
+
+MolParse evaluates models across the following core capability dimensions:
+
+### 1. Molecular Structure Perception
+
+Assess the ability to accurately recognize:
+- Atoms and bonds
+- Ring systems and fused structures
+- Substituents and functional groups
+- Variable attachment points and abstract structures
+
+### 2. Structured Chemical Representation
+
+Evaluate the capacity to translate molecular images into:
+- Linearized chemical strings
+- Structured symbolic representations
+- Machine-readable formats suitable for downstream reasoning
+
+### 3. Robustness in Real-World Documents
+
+Test model stability under:
+- Noisy or low-quality scans
+- Diverse drawing conventions
+- Crowded layouts and overlapping annotations
+- Variations in resolution and aspect ratio
+
+---
+
+## Dataset Characteristics
+
+- **Task Format**: Image-to-Structure Parsing
+- **Modalities**: Image + Text
+- **Domain**: Chemistry
+- **Languages**: English
+- **Annotation**: Expert-verified
+- **Data Scale**: Large-scale (millions of image–structure pairs)
+
+---
+
+## Task Types
+
+Each MolParse sample supports one or more of the following task types:
+
+1. **Molecular Image Captioning**  
+   Convert molecular diagrams into structured chemical strings.
+
+2. **Symbol and Topology Recognition**  
+   Identify atoms, bonds, rings, and connection patterns.
+
+3. **Complex Structure Parsing**  
+   Handle abstract rings, variable groups, and non-canonical layouts.
+
+4. **Noise-Robust Recognition**  
+   Maintain parsing accuracy under visual distortion or interference.
+
+---
+
+## Data Usage
+
+MolParse is suitable for:
+- Training end-to-end optical chemical structure recognition models
+- Evaluating vision-language and vision-only chemical parsers
+- Scientific document understanding pipelines
+- Downstream chemical reasoning and information extraction
+
+---
+
+## Download MolParse Dataset
+
+You can load the MolParse dataset using the HuggingFace `datasets` library:
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("InnovatorLab/MolParse")
+```
+## Evaluations
+
+We use [lmms-eval](https://github.com/EvolvingLMMs-Lab/lmms-eval) for evaluations.  
+Please refer to the files under [`./evaluation`](./evaluation/README.md) for detailed evaluation configurations and scripts.
+
+---
+
+## License
+
+MolParse is released under the **MIT License**.  
+See [LICENSE](./LICENSE) for more details.
+
+---

data/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e679f2538f961b50efe59822b98ae315c930a6dcb1561ec3fc25da1d011f150b
+size 34544964

evaluation/README.md

@@ -0,0 +1,3 @@
+# Evaluations of MolParse
+
+We evaluate the MolParse dataset using lmms-eval. The evaluation codes are listed in this folder.

evaluation/tasks/MolParse/MolParse.yaml

@@ -0,0 +1,30 @@
+dataset_path: "InnovatorLab/MolParse"
+task: "MolParse"
+test_split: "test"
+output_type: "generate_until"
+
+doc_to_visual: !function utils.doc_to_visual
+doc_to_text: !function utils.doc_to_text
+doc_to_target: !function utils.doc_to_target
+
+generation_kwargs:
+  max_new_tokens: 256
+  temperature: 0.0
+  top_p: 1.0
+  num_beams: 1
+  do_sample: false
+
+process_results: !function utils.process_results
+
+metric_list:
+  - metric: api_judge_accuracy
+    aggregation: !function utils.aggregation
+    higher_is_better: true
+
+lmms_eval_specific_kwargs:
+  default:
+    pre_prompt: ""
+    post_prompt: ""
+
+metadata:
+  - version: 1.0

evaluation/tasks/MolParse/utils.py

@@ -0,0 +1,95 @@
+import os
+from typing import Dict, Any, List
+from PIL import Image
+from openai import OpenAI
+
+API_KEY = os.environ.get("OPENAI_API_KEY", "EMPTY")
+API_BASE_URL = os.environ.get("OPENAI_BASE_URL", "http://localhost:8000/v1")
+MODEL_NAME = os.environ.get("OPENAI_MODEL_NAME", "default-model")
+
+client = OpenAI(
+    base_url=API_BASE_URL,
+    api_key=API_KEY,
+)
+
+def api_judge_answer(question: str, ground_truth: str, model_prediction: str) -> bool:
+    """
+    Use judge model API to judge if model prediction is correct
+    """
+    system_prompt = """You are a professional evaluation assistant. Please carefully compare whether the model's predicted answer matches the standard answer.
+
+Evaluation criteria:
+1. For chemical formulas/E-SMILES: Consider correct if structures are identical
+2. For numerical answers: Consider correct if values are the same (allow minor differences in decimal places)
+3. For text answers: Consider correct if semantics are the same
+4. For Yes/No questions: Consider correct if the answer direction is consistent
+
+Please only answer "correct" or "incorrect", do not explain the reasons."""
+
+    user_prompt = f"""Question: {question}
+
+Standard Answer: {ground_truth}
+Model Prediction: {model_prediction}
+
+Please judge whether the model prediction is correct? Only answer "correct" or "incorrect":"""
+
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.0,
+            max_tokens=10,
+        )
+        
+        judgment = completion.choices[0].message.content.strip().lower()
+        
+        if judgment == "correct":
+            return True
+        elif judgment == "incorrect":
+            return False
+        else:
+            print(f"Warning: Model returned unexpected judgment: '{judgment}'")
+            return False
+        
+    except Exception as e:
+        print(f"API judgment error: {e}")
+        return False
+
+def doc_to_visual(doc: Dict[str, Any]) -> List[Image.Image]:
+    images = doc.get("images", [])
+    if not images:
+        return []
+    if isinstance(images, Image.Image):
+        images = [images]
+    return [img.convert("RGB") for img in images]
+
+def doc_to_text(doc, lmms_eval_specific_kwargs=None):
+    pre_prompt = lmms_eval_specific_kwargs.get("pre_prompt", "") if lmms_eval_specific_kwargs else ""
+    post_prompt = lmms_eval_specific_kwargs.get("post_prompt", "") if lmms_eval_specific_kwargs else ""
+    content = doc.get("question", "")
+    return f"{pre_prompt}{content}{post_prompt}"
+
+def doc_to_target(doc):
+    return doc.get("answer", "")
+
+def process_results(doc: Dict[str, Any], results: List[str]) -> Dict[str, Any]:
+    prediction = results[0] if isinstance(results, list) else results
+    target = doc_to_target(doc)
+    question = doc_to_text(doc)
+    api_judge_correct = False
+    try:
+        api_judge_correct = api_judge_answer(question, target, prediction)
+    except Exception as e:
+        print(f"API judgment failed during process_results, using basic matching: {e}")
+    return {
+        "api_judge_accuracy": float(api_judge_correct),
+        "question": question,
+        "raw_output": prediction,
+        "ground_truth": target
+    }
+
+def aggregation(results: List[float]) -> float:
+    return sum(results) / len(results) if results else 0.0