Amaze Benchmark Description

There are a total of four maze shapes, with the structure as follows:

.
├── circle
│   └── maze-dataset
│       ├── maze_dataset_test.parquet
│       └── maze_dataset_train.parquet
├── hexagon
│   ├── maze-dataset
│   │   └── maze_dataset_test.parquet
│   └── maze-dataset_train
│       ├── maze_dataset_test.parquet
│       └── maze_dataset_train.parquet
├── square
│   ├── maze-dataset
│   │   └── maze_dataset_test.parquet
│   └── maze-dataset_train
│       ├── maze_dataset_test.parquet
│       └── maze_dataset_train.parquet
└── triangle
    ├── maze-dataset
    │   └── maze_dataset_test.parquet
    └── maze-dataset_train
        ├── maze_dataset_test.parquet
        └── maze_dataset_train.parquet

Under each shape subdirectory, maze_dataset represents the test set, with sizes ranging from 3*3 to 16*16, and each size has 50 samples, 700 samples in total; maze_dataset_train is the training set, with a size of 3*3, and 800 samples; maze_dataset_train/maze_dataset_test.parquet is the validation set, also with a size of 3*3, and 8 samples.

Table Structure (Column Descriptions)

Column Name	Type	Description
id	string	Unique sample identifier (UUID)
original_img	string	Unmarked maze image, Base64 encoded PNG
m_original_img	string	Maze image with start/end markers, Base64 encoded PNG; null if the corresponding file does not exist
instruction	string	Task instruction text (can be specified via --instruction)
sol_img	string	Solution image (blue path), Base64 encoded PNG
mask_img	string	Path mask image (Ground Truth path binary image), Base64 encoded PNG
cell_map	string	Cell segmentation map (cell map), Base64 encoded PNG
metadata	string	Metadata JSON corresponding to the maze, serialized as a single string (see structure below)

Default Instruction Text

The default instruction used is:

Add the blue solution path for the maze, connect start point (solid red circle)
to end point (red 'X' mark). Ensure all original maze elements
(walls, points, etc.) remain unchanged—only add the path.

Detailed Explanation of metadata Fields

The metadata column stores a single JSON string (parsable as a dictionary via json.loads(row["metadata"])):

Key	Type	Description
path_coordinates	array	Sequence of coordinates of the solution path on the grid; each item is [x, y] or a shape-specific coordinate representation, ordered from start to end
path_cell_ids	array	List of cell IDs on the solution path (corresponds to cell_map pixel values, used for alignment with the segmentation map)
start_cell	array | null	Start cell coordinates, e.g., [x, y]; null if no valid entrance/exit exists
end_cell	array | null	End cell coordinates, e.g., [x, y]; null if no valid entrance/exit exists
maze_config	object	Maze generation configuration, see table below
image_size	object	Rendered image size and drawing parameters, see table below
difficulty	object	Difficulty information based on path turns, see table below

maze_config Sub-object:

Key	Type	Description
shape	string	Shape: square / triangle / hexagon / circle
width	number	Grid width (square/triangle/hexagon)
height	number	Grid height (square/triangle/hexagon)
layers	number	Number of layers (valid only for circle mazes)
algorithm	string	Generation algorithm name, such as recursiveBacktrack, kruskal, wilson, etc.
seed	number	Random seed

image_size Sub-object:

Key	Type	Description
width	number	Maze image pixel width
height	number	Maze image pixel height
cell_size	number	Cell drawing size (pixels)
wall_width	number	Wall line width (pixels)

Dataset Class Example

class MazeDataset(Dataset):
    """Dataset class for loading maze data from parquet files."""

    def __init__(self, dataset_path: str, split: str = 'train'):
        """
        Initialize the maze dataset.

        Args:
            dataset_path: Path to the directory containing maze dataset files
            split: 'train' or 'test'
        """
        self.dataset_path = dataset_path
        self.split = split

        # Load the appropriate parquet file
        if split == 'train':
            file_path = os.path.join(dataset_path, 'maze_dataset_train.parquet')
        else:
            file_path = os.path.join(dataset_path, 'maze_dataset_test.parquet')

        if not os.path.exists(file_path):
            raise FileNotFoundError(f"Dataset file not found: {file_path}")

        # Load the parquet file
        self.data = pd.read_parquet(file_path)

        if 'instruction' in self.data.columns:
            self.prompts = self.data['instruction'].tolist()
        else:
            # If no specific column found, create dummy prompts
            self.prompts = [f"Navigate through maze {i}" for i in range(len(self.data))]

        # Store metadata for each sample
        self.metadata = []
        for idx, row in self.data.iterrows():
            metadata = {
                'index': idx,
                'split': split
            }
            # Add any additional columns as metadata
            for col in self.data.columns:
                if col not in ['instruction', 'text']:
                    metadata[col] = row[col]
            self.metadata.append(metadata)

    @staticmethod
    def decode_base64_image(base64_str: str) -> Optional[Image.Image]:
        """
        Decode base64 string to PIL Image.

        Args:
            base64_str: Base64 encoded image string

        Returns:
            PIL Image object or None if decoding fails
        """
        if not base64_str or pd.isna(base64_str):
            return None

        try:
            # Remove data URL prefix if present (e.g., "data:image/png;base64,")
            if base64_str.startswith('data:'):
                base64_str = base64_str.split(',', 1)[1]

            # Decode base64 string
            image_data = base64.b64decode(base64_str)

            # Convert to PIL Image
            image = Image.open(io.BytesIO(image_data))

            return image
        except Exception as e:
            print(f"Error decoding base64 image: {e}")
            return None

    def __len__(self):
        return len(self.prompts)

    def __getitem__(self, idx):
        metadata = self.metadata[idx].copy()
        row = self.data.iloc[idx]

        prompt = self.prompts[idx]


        sample_id = row.get('id', f"maze_{idx}")

        original_img = self.decode_base64_image(row.get('original_img'))
        m_original_img = self.decode_base64_image(row.get('m_original_img'))
        sol_img = self.decode_base64_image(row.get('sol_img'))
        mask_img = self.decode_base64_image(row.get('mask_img'))
        cell_map = self.decode_base64_image(row.get('cell_map'))


        return {
            "id": sample_id,
            "prompt": prompt,
            "original_img": original_img,      # 无标记迷宫
            "m_original_img": m_original_img,  # 带标记迷宫
            "sol_img": sol_img,                # 解答图像
            "mask_img": mask_img,              # 解空间mask
            "cell_map": cell_map,              # 格子分割图
            "metadata": metadata
        }

    @staticmethod
    def collate_fn(examples):
        """Collate function for batching"""
        return ...

Feel free to use it!