Upload folder using huggingface_hub

dataset_scripts/README.md

@@ -0,0 +1,63 @@
+# ControlNet Dataset Preprocessing Tool
+
+This script processes a dataset (e.g. COCO-Caption2017) to generate ControlNet-compatible training data, such as Canny edge maps or depth maps.
+
+## Usage
+
+```bash
+python -m {dataset_name}.preprocess [OPTIONS]
+```
+
+For example:
+
+```bash
+python -m coco.preprocess \
+  --output_dir ./controlnet_data \
+  --cn_type canny \
+  --sample_size 10000 \
+  --enable_blur \
+  --dataset COCO-Caption2017 \
+  --split val
+```
+
+## Command Line Arguments
+
+| Argument | Type | Default | Description |
+|----------|------|---------|-------------|
+| `--output_dir` | `str` | `../dataset/controlnet_datasets` | Directory where the processed data will be saved. |
+| `--cn_type` | `str` | `canny` | Type of control map to generate. Options: `canny`, `depth`. |
+| `--sample_size` | `int` | `5000` | Maximum number of samples to process. |
+| `--enable_blur` | flag | `False` | Enable Gaussian blur preprocessing for Canny edge detection. |
+| `--blur_kernel_size` | `int` | `3` | Kernel size used for Gaussian blur (must be odd). |
+| `--dataset` | `str` | `COCO-Caption2017` | Name of the dataset to use. |
+| `--split` | `str` | `val` | Dataset split to process (`train`, `val`, etc.). |
+| `--enable_no_prompt` | flag | `False` | If set, removes prompts from the output. |
+| `--random_sample` | flag | `False` | If set, randomly samples from the dataset instead of sequential order. |
+
+## Notes
+
+- **Canny mode** uses OpenCV edge detection; enabling `--enable_blur` can improve edge clarity.
+- This tool is often used to generate paired image/control map datasets for ControlNet training or finetuning.
+
+## Dependencies
+
+Make sure to install any required packages before running the script:
+
+```bash
+pip install opencv-python tqdm
+```
+
+## Output Structure
+
+The script will generate a directory with the following structure:
+
+```
+output_dir/
+├── images/
+│   ├── 000001.jpg
+│   └── ...
+├── controls/
+│   ├── 000001.png  # e.g., Canny edge or depth map
+│   └── ...
+└── meta.json       # Optional metadata
+```

dataset_scripts/caption_control_dataset.py

@@ -0,0 +1,59 @@
+from typing import OrderedDict
+import os
+import json
+import torch
+from torch.utils.data import Dataset
+from backend.torch.utils import load_image
+
+class LimitedCache:
+    def __init__(self, max_size):
+        self.cache = OrderedDict()
+        self.max_size = max_size
+
+    def get(self, key, loader_fn):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        else:
+            value = loader_fn(key)
+            self.cache[key] = value
+            if len(self.cache) > self.max_size:
+                self.cache.popitem(last=False)
+            return value
+
+class CaptionControlDataset(Dataset):
+    @staticmethod
+    def collate_fn(batch):
+        return [(prompt, image, control) for prompt, image, control in batch]
+
+    def __init__(self, path, cache_size=1024):
+        super().__init__()
+        self.base_path = path
+        with open(os.path.join(path, "metadata.json"), "r") as f:
+            self.metadata = json.load(f)
+
+        self.image_cache = LimitedCache(cache_size)
+        self.control_cache = LimitedCache(cache_size)
+
+    def __len__(self):
+        return len(self.metadata)
+
+    def __getitem__(self, idx):
+        item = self.metadata[idx]
+        prompt = item["prompt"]
+        image_path = os.path.join(self.base_path, item["image"])
+        control_path = os.path.join(self.base_path, item["control"])
+
+        image = self.image_cache.get(image_path, load_image)
+        control = self.control_cache.get(control_path, load_image)
+
+        return prompt, image, control
+
+    def get_dataloader(self, batch_size=1, shuffle=False, **kwargs):
+        return torch.utils.data.DataLoader(
+            self,
+            batch_size=batch_size,
+            shuffle=shuffle,
+            collate_fn=self.collate_fn,
+            **kwargs,
+        )

dataset_scripts/coco/coco_dataset.py

@@ -0,0 +1,18 @@
+from dataset.caption_control_dataset import CaptionControlDataset
+
+COCODataset = CaptionControlDataset
+
+if __name__ == "__main__":
+    dataset = COCODataset(
+        path="../dataset/controlnet_datasets/COCO-Caption2017-canny", cache_size=16
+    )
+    data_loader = dataset.get_dataloader(batch_size=1)
+
+    for i, batch in enumerate(data_loader):
+        prompt, image, control = batch[0]
+        print("prompt:", prompt)
+        print("image:", image)
+        print("control:", control)
+        print("--------------")
+        if i > 10:
+            break

dataset_scripts/coco/preprocess.py

@@ -0,0 +1,176 @@
+import time
+import os
+import random
+from tqdm import tqdm  # To measure processing time
+from dataset.processor import ControlNetPreprocessor
+from datasets import load_dataset
+
+
+def create_dataset(
+    preprocessor,
+    dataset,
+    output_dir,
+    enable_no_prompt=False,
+):
+    """
+    Creates a ControlNet dataset by processing images from a source dataset.
+    
+    Args:
+        preprocessor: The ControlNetPreprocessor instance
+        dataset: The source dataset (e.g., COCO)
+        output_dir: Directory to save the processed dataset
+        cn_type: Type of control map ('canny' or 'depth')
+        limit: Maximum number of samples to process (None for all)
+    
+    Returns:
+        Path to the created dataset
+    """
+    import os
+    import json
+
+    # Create output directories
+    dataset_dir = output_dir
+    images_dir = os.path.join(dataset_dir, "images")
+    controls_dir = os.path.join(dataset_dir, "controls")
+
+    os.makedirs(dataset_dir, exist_ok=True)
+    os.makedirs(images_dir, exist_ok=True)
+    os.makedirs(controls_dir, exist_ok=True)
+
+    # Prepare metadata
+    metadata = []
+
+    total_samples = len(dataset)
+    print(f"Processing {total_samples} samples for ControlNet {preprocessor.cn_type} dataset...")
+    # Process each sample
+    for i, sample in enumerate(
+        tqdm(dataset, total=total_samples, desc="Processing samples")
+    ):
+        input_image = sample["image"]
+        prompt = ""
+        if "answer" in sample and sample["answer"]:
+            for ans in sample["answer"]: 
+                prompt += (ans+" ")
+        # for debug only
+        # if i < 6:
+        #     print(f"prompt: {prompt}")
+        #     if i == 5:
+        #         return
+        # Process image with ControlNet preprocessor
+        try:
+            control_map = preprocessor.process(image=input_image)
+
+            # Save original image and control map
+            image_filename = f"image_{i:06d}.jpg"
+            control_filename = f"control_{i:06d}.jpg"
+
+            input_image.save(os.path.join(images_dir, image_filename))
+            control_map.save(os.path.join(controls_dir, control_filename))
+
+            # Add to metadata
+            metadata.append(
+                {
+                    "id": i,
+                    "prompt": prompt,
+                    "image": f"images/{image_filename}",
+                    "control": f"controls/{control_filename}",
+                }
+            )
+        except Exception as e:
+            print(f"Error processing sample {i}: {e}")
+            continue
+
+    # Save metadata
+    metadata_path = os.path.join(dataset_dir, "metadata.json")
+    with open(metadata_path, "w") as f:
+        json.dump(metadata, f, indent=2)
+
+    print(f"Dataset created at: {dataset_dir}")
+    print(f"Total processed samples: {len(metadata)}")
+    return dataset_dir
+
+def parse_args():
+    import argparse
+    # Set up command line arguments
+    parser = argparse.ArgumentParser(description="Create ControlNet dataset from COCO")
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="../dataset/controlnet_datasets",
+        help="Directory to save the processed dataset",
+    )
+    parser.add_argument(
+        "--cn_type",
+        type=str,
+        default="canny",
+        choices=["canny", "depth"],
+        help="Type of control map to generate",
+    )
+    parser.add_argument(
+        "--sample_size", type=int, default=5000, help="Maximum number of samples to process"
+    )
+    parser.add_argument(
+        "--enable_blur",
+        action="store_true",
+        help="Enable Gaussian blur for Canny edge detection",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="COCO-Caption2017",
+        help="Dataset to use (default: COCO-Caption2017)",
+    )
+    parser.add_argument(
+        "--split", type=str, default="val", help="Dataset split to use (default: val)"
+    )
+    parser.add_argument(
+        "--blur_kernel_size",
+        type=int,
+        default=3,
+        help="Kernel size used to blur the image before Canny edge detection (must be odd)",
+    )
+    parser.add_argument("--enable_no_prompt", action="store_true")
+    parser.add_argument("--random_sample", action="store_true")
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    print("Loading dataset...")
+
+    # Load the dataset
+    try:
+        # determine the total number of samples
+        dataset = load_dataset(os.path.join("../dataset", args.dataset), split=args.split, trust_remote_code=True)
+        # random sample
+        if args.sample_size is not None and args.random_sample:
+            total_samples = min(args.sample_size, len(dataset))
+            indices = random.sample(range(len(dataset)), total_samples)
+            dataset = dataset.select(indices)  # HuggingFace way
+        elif args.sample_size is not None:
+            dataset = dataset.select(range(args.sample_size))
+            
+        dataset.name = args.dataset
+        print(f"Number of examples: {len(dataset)}")
+        print("Dataset features:", dataset.features)
+    except Exception as e:
+        print(f"Error loading dataset: {e}")
+        print(
+            "Please ensure you have an internet connection and the dataset name is correct."
+        )
+        exit()
+
+    # Initialize preprocessor
+    preprocessor = ControlNetPreprocessor(
+        enable_blur=args.enable_blur, blur_kernel_size=args.blur_kernel_size, cn_type=args.cn_type
+    )
+
+    # Create ControlNet dataset
+    dataset_dir = create_dataset(
+        preprocessor=preprocessor,
+        dataset=dataset,
+        output_dir=os.path.join(args.output_dir, f"{args.dataset}-{args.cn_type}"),
+        enable_no_prompt=args.enable_no_prompt,
+    )
+
+    print("Done!")

dataset_scripts/dci/dci_dataset.py

@@ -0,0 +1,16 @@
+from dataset.caption_control_dataset import CaptionControlDataset
+
+DCIDataset = CaptionControlDataset
+
+if __name__ == "__main__":
+    dataset = DCIDataset(path="../dataset/controlnet_datasets/DCI-30K-canny", cache_size=16)
+    data_loader = dataset.get_dataloader(batch_size=1)
+
+    for i, batch in enumerate(data_loader):
+        prompt, image, control = batch[0]
+        print("prompt:", prompt)
+        print("image:", image)
+        print("control:", control)
+        print("--------------")
+        if i > 10:
+            break

dataset_scripts/dci/preprocess.py

@@ -0,0 +1,172 @@
+import time
+import re
+import os
+from tqdm import tqdm  # To measure processing time
+from backend.torch.utils import load_image
+from dataset.processor import ControlNetPreprocessor
+import random
+
+
+def create_dataset(
+    preprocessor,
+    dataset_dir,
+    output_dir,
+    enable_extra_caption=True,
+    sample_size=5000,
+):
+    """
+    Creates a ControlNet dataset by processing images from a source dataset.
+    
+    Args:
+        preprocessor: The ControlNetPreprocessor instance
+        dataset_dir: The source dataset (e.g., COCO)
+        output_dir: Directory to save the processed dataset
+        cn_type: Type of control map ('canny' or 'depth')
+        limit: Maximum number of samples to process (None for all)
+    
+    Returns:
+        Path to the created dataset
+    """
+    import os
+    import json
+
+    # Create output directories
+    images_dir = os.path.join(output_dir, "images")
+    controls_dir = os.path.join(output_dir, "controls")
+
+    os.makedirs(output_dir, exist_ok=True)
+    os.makedirs(images_dir, exist_ok=True)
+    os.makedirs(controls_dir, exist_ok=True)
+
+    # Prepare metadata
+    metadata = []
+
+    def list_matching_file_paths_regex(folder_path, pattern):
+        regex = re.compile(pattern)
+        return [
+            os.path.join(folder_path, f)
+            for f in os.listdir(folder_path)
+            if os.path.isfile(os.path.join(folder_path, f)) and regex.fullmatch(f)
+        ]
+
+    origin_data = list_matching_file_paths_regex(
+        os.path.join(dataset_dir, "annotations"), r".*\.json"
+    )
+
+    total_samples = len(origin_data) if sample_size is None else min(sample_size, len(origin_data))
+    origin_data = random.sample(origin_data, total_samples)
+    print(f"Processing {total_samples} samples for ControlNet {preprocessor.cn_type} dataset...")
+
+    for i, orig in enumerate(
+        tqdm(origin_data, total=total_samples, desc="Processing samples")
+    ):
+        with open(orig, "r") as file:
+            d = json.load(file)
+
+        if "image" not in d:
+            raise KeyError()
+
+        input_image = load_image(os.path.join(dataset_dir, "photos", d["image"]))
+        prompt = d.get("short_caption", "")
+
+        if enable_extra_caption and "extra_caption" in d:
+            prompt = prompt + " " + d["extra_caption"]
+
+        try:
+            control_map = preprocessor.process(image=input_image)
+
+            # Save original image and control map
+            image_filename = f"image_{i:06d}.jpg"
+            control_filename = f"control_{i:06d}.jpg"
+
+            input_image.save(os.path.join(images_dir, image_filename))
+            control_map.save(os.path.join(controls_dir, control_filename))
+
+            # Add to metadata
+            metadata.append(
+                {
+                    "id": i,
+                    "prompt": prompt,
+                    "image": f"images/{image_filename}",
+                    "control": f"controls/{control_filename}",
+                }
+            )
+        except Exception as e:
+            print(f"Error processing sample {i}: {e}")
+            continue
+
+    # Save metadata
+    metadata_path = os.path.join(output_dir, "metadata.json")
+    with open(metadata_path, "w") as f:
+        json.dump(metadata, f, indent=2)
+
+    print(f"Dataset created at: {output_dir}")
+    print(f"Total processed samples: {len(metadata)}")
+    return output_dir
+
+def parse_args():
+    import argparse
+    # Set up command line arguments
+    parser = argparse.ArgumentParser(description="Create ControlNet dataset from COCO")
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="../dataset/controlnet_datasets",
+        help="Directory to save the processed dataset",
+    )
+    parser.add_argument(
+        "--cn_type",
+        type=str,
+        default="canny",
+        choices=["canny", "depth"],
+        help="Type of control map to generate",
+    )
+    parser.add_argument(
+        "--enable_blur",
+        action="store_true",
+        help="Enable Gaussian blur for Canny edge detection",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="DCI",
+        help="Dataset to use (default: DCI)",
+    )
+    parser.add_argument(
+        "--dataset_dir",
+        type=str,
+        default="../dataset/densely_captioned_images",
+        help="Dataset to use (default: densely_captioned_images)",
+    )
+    parser.add_argument(
+        "--blur_kernel_size",
+        type=int,
+        default=3,
+        help="Kernel size used to blur the image before Canny edge detection (must be odd)",
+    )
+    parser.add_argument(
+        "--sample_size", type=int, default=5000, help="Maximum number of samples to process"
+    )
+    parser.add_argument("--disable_extra_caption", action="store_true")
+    args = parser.parse_args()
+    return args
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Initialize preprocessor
+    preprocessor = ControlNetPreprocessor(
+        enable_blur=args.enable_blur, blur_kernel_size=args.blur_kernel_size, cn_type=args.cn_type
+    )
+
+    # Create ControlNet dataset
+    dataset_dir = create_dataset(
+        preprocessor=preprocessor,
+        dataset_dir=args.dataset_dir,
+        output_dir=os.path.join(args.output_dir, f"{args.dataset}-{args.cn_type}"),
+        enable_extra_caption=(not args.disable_extra_caption),
+        sample_size=args.sample_size,
+    )
+
+    print(f"\nControlNet dataset created at: {dataset_dir}")
+    print("Done!")

dataset_scripts/mjhq/mjhq_dataset.py

@@ -0,0 +1,18 @@
+from dataset.caption_control_dataset import CaptionControlDataset
+
+MJHQDataset = CaptionControlDataset
+
+if __name__ == "__main__":
+    dataset = MJHQDataset(
+        path="../dataset/controlnet_datasets/MJHQ-30K-canny", cache_size=16
+    )
+    data_loader = dataset.get_dataloader(batch_size=1)
+
+    for i, batch in enumerate(data_loader):
+        prompt, image, control = batch[0]
+        print("prompt:", prompt)
+        print("image:", image)
+        print("control:", control)
+        print("--------------")
+        if i > 10:
+            break

dataset_scripts/mjhq/preprocess.py

@@ -0,0 +1,195 @@
+from tqdm import tqdm  # To measure processing time
+from dataset.processor import ControlNetPreprocessor
+from datasets import load_dataset
+from PIL import Image
+import os
+import json
+import random
+import shutil
+
+
+def create_dataset(
+    preprocessor,
+    input_dir,
+    output_dir,
+    samples_per_category=500,
+):
+    """
+    Create a dataset for ControlNet from the specified dataset directory.
+    Args:
+        input_dir (str): Path to the input dataset directory.
+        output_dir (str): Path to the output directory containing images and metadata.
+    Returns:
+        str: Path to the created dataset directory.
+    """
+    ORIGINAL_METADATA_FILE = "meta_data.json"
+    CATEGORIES = [
+        'animals', 'art', 'fashion', 'food', 'indoor',
+        'landscape', 'logo', 'people', 'plants', 'vehicles'
+    ]
+    # Create output directories
+    images_output_dir = os.path.join(output_dir, "images")
+    controls_output_dir = os.path.join(output_dir, "controls")
+
+    os.makedirs(output_dir, exist_ok=True)
+    os.makedirs(images_output_dir, exist_ok=True)
+    os.makedirs(controls_output_dir, exist_ok=True)
+
+    # Prepare metadata
+    metadata = []
+
+    # read metainfo from dataset_dir
+    try:
+        with open(os.path.join(input_dir, ORIGINAL_METADATA_FILE), 'r', encoding='utf-8') as f:
+                original_metadata = json.load(f)
+    except FileNotFoundError:
+        print(f"ERROR: Original metadata file not found at {os.path.join(input_dir, ORIGINAL_METADATA_FILE)}")
+        print("Please ensure the path is correct and the file exists.")
+        return
+    except json.JSONDecodeError:
+        print(f"ERROR: Could not decode JSON from {os.path.join(input_dir, ORIGINAL_METADATA_FILE)}. Is it a valid JSON file?")
+        return
+    
+    # Iterate through categories to sample and copy images
+    id = 0
+    for category in CATEGORIES:
+        print(f"\nProcessing category: {category}...")
+
+        original_category_path = os.path.join(input_dir, category)
+
+        if not os.path.isdir(original_category_path):
+            print(f"  WARNING: Original category folder not found: {original_category_path}. Skipping.")
+            continue
+
+        # List all image files in the original category folder
+        try:
+            all_images_in_category = [
+                f for f in os.listdir(original_category_path)
+            ]
+        except FileNotFoundError:
+             print(f"  ERROR: Could not list files in {original_category_path}. Check permissions or path.")
+             continue
+
+        if not all_images_in_category:
+            print(f"  WARNING: No image files found in {original_category_path} for category {category}. Skipping.")
+            continue
+
+        print(f"  Found {len(all_images_in_category)} images in original '{category}' folder.")
+
+        # Randomly select SAMPLES_PER_CATEGORY image filenames
+        if len(all_images_in_category) < samples_per_category:
+            print(f"  WARNING: Category '{category}' has only {len(all_images_in_category)} images, "
+                  f"which is less than the required {samples_per_category}. Taking all available images.")
+            sampled_image_filenames_with_ext = all_images_in_category
+        else:
+            sampled_image_filenames_with_ext = random.sample(all_images_in_category, samples_per_category)
+
+        print(f"  Sampling {len(sampled_image_filenames_with_ext)} images for '{category}'.")
+        
+        for img_filename_with_ext in sampled_image_filenames_with_ext:
+            img_base_filename = os.path.splitext(img_filename_with_ext)[0]
+            if img_base_filename in original_metadata:
+                image_filename = f"image_{id:06d}.jpg"
+                src_img_path = os.path.join(original_category_path, img_filename_with_ext)
+                dst_img_path = os.path.join(images_output_dir, image_filename) # Destination is now the shared folder
+                
+                # Copy the image file to the single 'images' folder
+                try:
+                    shutil.copy2(src_img_path, dst_img_path) # copy2 preserves metadata
+                except Exception as e:
+                    print(f"    ERROR copying {src_img_path} to {dst_img_path}: {e}")
+                    continue # Skip this image if copying fails
+                
+                # Save original image and control map
+                control_map = preprocessor.process(image=Image.open(dst_img_path))
+                control_filename = f"control_{id:06d}.jpg"
+                control_map.save(os.path.join(controls_output_dir, control_filename))
+                
+                # Get the prompt from original metadata
+                prompt = original_metadata[img_base_filename].get("prompt", "")
+                
+                # Add to metadata
+                metadata.append(
+                    {
+                        "id": id,
+                        "prompt": prompt,
+                        "image": f"images/{image_filename}",
+                        "control": f"controls/{control_filename}",
+                    }
+                )
+                id += 1
+            else:
+                print(f"  WARNING: Metadata key '{img_base_filename}' (from file '{img_filename_with_ext}') "
+                      f"not found in original_metadata.json. Skipping this image.")
+
+    # 4. Save new metadata
+    # Save metadata
+    metadata_path = os.path.join(output_dir, "metadata.json")
+    with open(metadata_path, "w") as f:
+        json.dump(metadata, f, indent=2)
+    print(f"Dataset created at: {output_dir}")
+    print(f"Total processed samples: {len(metadata)}")
+
+    return output_dir
+    
+def parse_args():
+    import argparse
+    # Set up command line arguments
+    parser = argparse.ArgumentParser(description="Create ControlNet dataset from datasets")
+    parser.add_argument(
+        "--cn_type",
+        type=str,
+        default="canny",
+        choices=["canny", "depth"],
+        help="Type of control map to generate",
+    )
+    parser.add_argument(
+        "--enable_blur",
+        action="store_true",
+        help="Enable Gaussian blur for Canny edge detection",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="MJHQ-30K",
+        help="Dataset to use (default: MJHQ-30K)",
+    )
+    parser.add_argument(
+        "--dataset_dir",
+        type=str,
+        default="../dataset",
+        help="Dataset to use (default: COCO-Caption2017)",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="../dataset/controlnet_datasets",
+        help="Directory to save the processed dataset",
+    )
+    parser.add_argument(
+        "--blur_kernel_size",
+        type=int,
+        default=3,
+        help="Kernel size used to blur the image before Canny edge detection (must be odd)",
+    )
+    parser.add_argument("--enable_no_prompt", action="store_true")
+    return parser.parse_args()
+ 
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    # Initialize preprocessor
+    preprocessor = ControlNetPreprocessor(
+        enable_blur=args.enable_blur, blur_kernel_size=args.blur_kernel_size,cn_type=args.cn_type
+    )
+    # Create anno dataset
+    control_dataset_dir = create_dataset(
+        preprocessor=preprocessor,
+        input_dir=os.path.join(args.dataset_dir, args.dataset),
+        output_dir=os.path.join(args.output_dir, f"{args.dataset}-{args.cn_type}"),
+        samples_per_category=500,  # Number of samples per category
+    )
+
+    print(f"\nControlNet dataset created at: {control_dataset_dir}")
+    print("Done!")

dataset_scripts/processor.py

@@ -0,0 +1,168 @@
+import time
+from PIL import Image
+import numpy as np
+import cv2
+import torch
+from transformers import DPTFeatureExtractor, DPTForDepthEstimation
+
+# TODO: Add self.cn_type to control the control map type
+# Then check the relative imports of this processor in benchmark
+class ControlNetPreprocessor:
+    """
+    A class to preprocess images for ControlNet input (Canny edges, Depth maps).
+    """
+
+    def __init__(self, enable_blur=True, blur_kernel_size=3, cn_type="canny", device=None):
+        """
+        Initializes the preprocessor, loading necessary models.
+        Args:
+            device (str, optional): The device to run models on ('cuda', 'cpu').
+                                    Defaults to 'cuda' if available, else 'cpu'.
+        """
+        print("Initializing ControlNetPreprocessor...")
+        self.cn_type = cn_type
+        # --- Device Setup ---
+        if device is None:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        else:
+            self.device = torch.device(device)
+        print(f"Using device: {self.device}")
+
+        # --- Canny Edge Setup ---
+        if self.cn_type == "canny":
+
+            self.canny_low_threshold = 100
+            self.canny_high_threshold = 200
+            self.canny_blur_kernel_size = blur_kernel_size  # Must be odd
+            self.enable_blur = enable_blur
+
+            assert (
+                self.canny_blur_kernel_size % 2 != 0
+            ), "Warning: Blur kernel size must be odd."
+            print("Canny edge detector configured.")
+        
+        # --- Depth Estimation Setup ---
+        # Using Intel's DPT model (Dense Prediction Transformer) via Hugging Face
+        elif self.cn_type == "depth":
+            depth_model_name = "Intel/dpt-large"  # Or try "Intel/dpt-hybrid-midas" for potentially faster/different results
+            print(f"Loading depth estimation model: {depth_model_name}...")
+            start_time = time.time()
+            try:
+                self.depth_feature_extractor = DPTFeatureExtractor.from_pretrained(
+                    depth_model_name
+                )
+                self.depth_model = DPTForDepthEstimation.from_pretrained(depth_model_name)
+                self.depth_model.to(self.device)
+                self.depth_model.eval()  # Set model to evaluation mode
+                print(
+                    f"Depth model loaded to {self.device} in {time.time() - start_time:.2f} seconds."
+                )
+            except Exception as e:
+                print(f"Error loading depth model: {e}")
+                print("Please ensure 'transformers' and 'torch' are installed correctly.")
+                # Optionally handle the error, e.g., disable depth processing
+                self.depth_model = None
+                self.depth_feature_extractor = None
+
+            print("Preprocessor initialization complete.")
+
+    def _to_numpy(self, image: Image.Image) -> np.ndarray:
+        """Converts PIL Image to NumPy array (RGB)."""
+        return np.array(image.convert("RGB"))
+
+    def get_canny_map(self, image: Image.Image) -> Image.Image:
+        """
+        Generates a Canny edge map from the input image.
+        Args:
+            image (PIL.Image.Image): Input image.
+        Returns:
+            PIL.Image.Image: Grayscale Canny edge map.
+        """
+        if not isinstance(image, Image.Image):
+            raise TypeError("Input must be a PIL Image.")
+
+        image_np = self._to_numpy(image)
+        # 1. Convert to grayscale for Canny
+        image_gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
+
+        # 2. Edeg detection. Apply Gaussian Blur to reduce noise and fine details if needed
+        if self.enable_blur:
+            kernel_size = (self.canny_blur_kernel_size, self.canny_blur_kernel_size)
+            image_blurred = cv2.GaussianBlur(image_gray, kernel_size, 0)
+            edges = cv2.Canny(
+                image_blurred, self.canny_low_threshold, self.canny_high_threshold
+            )
+        else:
+            edges = cv2.Canny(
+                image_gray, self.canny_low_threshold, self.canny_high_threshold
+            )
+
+        # ControlNet often expects edges as white lines on black background
+        # Invert if needed (some models might expect black lines on white)
+        # edges = 255 - edges
+        return Image.fromarray(edges).convert("L")  # Ensure grayscale PIL image
+
+    def get_depth_map(self, image: Image.Image) -> Image.Image | None:
+        """
+        Generates a depth map from the input image using a DPT model.
+        Args:
+            image (PIL.Image.Image): Input image.
+        Returns:
+            PIL.Image.Image | None: Grayscale depth map (closer is often brighter/whiter,
+                                    but depends on normalization), or None if model failed to load.
+        """
+        if self.depth_model is None or self.depth_feature_extractor is None:
+            print("Depth model not available.")
+            return None
+        if not isinstance(image, Image.Image):
+            raise TypeError("Input must be a PIL Image.")
+
+        original_size = image.size  # W, H
+
+        # Prepare image for the model
+        inputs = self.depth_feature_extractor(images=image, return_tensors="pt")
+        pixel_values = inputs.pixel_values.to(self.device)
+
+        # Inference
+        with torch.no_grad():
+            outputs = self.depth_model(pixel_values)
+            predicted_depth = outputs.predicted_depth  # This is raw output (logits)
+
+        # Interpolate prediction to original image size
+        # Note: PIL size is (W, H), interpolate expects (H, W)
+        prediction = torch.nn.functional.interpolate(
+            predicted_depth.unsqueeze(1),
+            size=original_size[::-1],  # Reverse to (H, W)
+            mode="bicubic",
+            align_corners=False,
+        )
+
+        # Normalize and format output
+        output = prediction.squeeze().cpu().numpy()
+        # Normalize to 0-1 range
+        formatted = (output - np.min(output)) / (np.max(output) - np.min(output))
+        # Scale to 0-255 and convert to uint8 grayscale image
+        depth_map_np = (formatted * 255).astype(np.uint8)
+        depth_map_image = Image.fromarray(depth_map_np).convert(
+            "L"
+        )  # Ensure grayscale PIL image
+
+        return depth_map_image
+
+    def process(
+        self, image: Image.Image
+    ) -> tuple[Image.Image | None, Image.Image | None]:
+        """
+        Generates both Canny edge map and depth map for the input image.
+        Args:
+            image (PIL.Image.Image): Input image.
+        Returns:
+            tuple[Image.Image | None, Image.Image | None]: (canny_map, depth_map)
+        """
+        if self.cn_type == "canny":
+            res_map = self.get_canny_map(image)
+        elif self.cn_type == "depth":
+            res_map = self.get_depth_map(image)
+        else:
+            print("Type does not exist")
+        return res_map