encode.py

import io
import os
import queue
import threading

import jax
import numpy as np
import PIL.Image
import tqdm

from typing import Callable, Generator, Iterator
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from functools import partial

from datasets import load_dataset, IterableDatasetDict, Image as HFImage
from diffusers import FlaxAutoencoderKL
from PIL import PngImagePlugin

from quantization import optimized_for_sdxl, QuantizationType


PngImagePlugin.MAX_TEXT_CHUNK = 100 * (1024 * 1024)  # MB


def load_encoder_decoder() -> Callable[[jax.Array], jax.Array]:
    
    vae, params = FlaxAutoencoderKL.from_pretrained(
        "stabilityai/stable-diffusion-xl-base-1.0", subfolder="vae")
        
    def encode(x):
        x = x.transpose((0, 3, 1, 2))
        x = vae.apply({"params": params}, x, method=vae.encode).latent_dist.mean
        x = x * vae.config.scaling_factor
        return x
    
    def decode(x):
        x = x / vae.config.scaling_factor
        x = x.transpose((0, 3, 1, 2))
        x = vae.apply({"params": params}, x, method=vae.decode).sample
        x = x.transpose((0, 2, 3, 1))
        return x
    
    return encode, decode


def load_encoder():
    return load_encoder_decoder()[0]


def load_decoder():
    return load_encoder_decoder()[1]


def stream_imagenet_raw() -> IterableDatasetDict:
    return load_dataset(
        path="ILSVRC/imagenet-1k", 
        revision="4603483700ee984ea9debe3ddbfdeae86f6489eb",
        streaming=True, 
        trust_remote_code=True, 
    ).cast_column("image", HFImage(decode=False))


BatchType = tuple[np.ndarray, tuple[int], tuple[str]]


def get_name(item: dict):
    return os.path.basename(os.path.splitext(item["image"]["path"])[0])


def process_imagenet_batch(
    batch: list[dict], 
    size: int,
    resampling: PIL.Image.Resampling = PIL.Image.Resampling.LANCZOS,
) -> BatchType:

    def process_example(item: dict) -> tuple[np.ndarray, int, str]:
        label = item["label"]
        image_bytes = item["image"]["bytes"]
        image = PIL.Image.open(io.BytesIO(image_bytes)).convert("RGB")
        width, height = image.size
        short_edge = min(width, height)
        left = (width - short_edge) // 2
        upper = (height - short_edge) // 2
        right = left + short_edge
        lower = upper + short_edge
        image = image.crop((left, upper, right, lower))
        image = image.resize((size, size), resample=resampling)
        image = np.asarray(image)
        name = get_name(item)
        return image, label, name
    
    images, labels, names = zip(*map(process_example, batch))
    images = np.array(images, dtype=np.float32) / 127.5 - 1
    return images, labels, names


def parallel_process_dataset(
    dataset_iterator: Iterator[BatchType],
    batch_processor: Callable[[list[dict]], BatchType],
    batch_size: int,
    max_workers: int,
    prefetch_factor: int = 2,
    filter_fn: Callable[[dict], bool] = lambda _: True,
) -> Generator[BatchType, None, None]:

    queue_size = max_workers * prefetch_factor
    results_queue = queue.Queue(maxsize=queue_size)
    done_loading = threading.Event()
    
    def queue_filler():
        current_batch = []
        dataset_exhausted = False
        pending_futures = set()
        counter = 0
        
        # Outer loop: check for processed batches and enqueue them.
        while pending_futures or not dataset_exhausted:
        
            # Middle loop: submit new batch processing jobs.
            while len(pending_futures) < queue_size and not dataset_exhausted:
                
                # Inner loop: grow the batch from the iterator.
                while len(current_batch) < batch_size and not dataset_exhausted:    
                    try:
                        item = next(dataset_iterator)
                        counter += 1
                        if filter_fn(item):
                            current_batch.append(item)
                        else:
                            print("skipping item", counter)
                    except StopIteration:
                        dataset_exhausted = True
                        break
                
                # We have a full batch, so submit it to the parallel executor. 
                if current_batch:
                    future = executor.submit(batch_processor, current_batch)
                    pending_futures.add(future)
                    current_batch = []
                else:
                    break
            
            # Filter the finished jobs from the pending jobs. 
            done_futures = {f for f in pending_futures if f.done()}
            pending_futures -= done_futures

            # Enqueue all the finished batches.
            for future in done_futures:    
                try:
                    results_queue.put(future.result())
                except Exception as e:
                    print(f"Error processing batch: {e}")
        
        # No more pending jobs or dataset elements left to process. 
        done_loading.set()
    
    # Run the queue filler in a separate thread (batch processing is still multiprocess). 
    with ProcessPoolExecutor(max_workers=max_workers) as executor:
        thread = threading.Thread(target=queue_filler, daemon=True)
        thread.start()
    
        # Main loop: pop batches from queue until dataset is exhausted.
        while not (done_loading.is_set() and results_queue.empty()):
            yield results_queue.get()
            results_queue.task_done()
        thread.join()


def gen_codes(
    dataset_iterator: Iterator[BatchType],
    batch_processor: Callable[[list[dict]], BatchType],
    encoder: Callable[[jax.Array], jax.Array],
    batch_size: int,
    num_workers: int,
    quantization: QuantizationType = optimized_for_sdxl,
    filter_fn: Callable[[dict], bool] = lambda _: True,
) -> Generator[BatchType, None, None]:
    
    @jax.jit
    def encode_and_quantize(x):
        return quantization.quantize(encoder(x))
    
    for images, labels, names in parallel_process_dataset(
        dataset_iterator,
        batch_processor=batch_processor,
        batch_size=batch_size,
        max_workers=num_workers,
        filter_fn=filter_fn,
    ):
        codes = np.array(encode_and_quantize(images))
        yield codes, labels, names


def get_save_path(label: int, output_dir: str, name: str) -> str:
    folder_name = f"{label:03d}" if label >= 0 else "UNK"
    folder_path = os.path.join(output_dir, folder_name)
    img_path = os.path.join(folder_path, f"{name}.png")
    return img_path


def save_image(
    image: np.ndarray, 
    label: int, 
    output_dir: str,
    name: str,
    overwrite: bool = False,
) -> str:
    img_path = get_save_path(label, output_dir, name)
    os.makedirs(os.path.dirname(img_path), exist_ok=True)
    if overwrite or not os.path.exists(img_path):
        PIL.Image.fromarray(image).save(img_path)
    return img_path


def save_images_async(
    loader: Generator[BatchType, None, None], 
    output_dir: str, 
    max_workers: int,
) -> list[str]:
    
    futures = set()
    exception_event = threading.Event()
    exception = [None]

    def signal_error(future):
        try:
            future.result()
        except Exception as exc:
            exception[0] = exc
            exception_event.set()
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        for batch in loader:
            for image, label, name in zip(*batch):
                future = executor.submit(
                    save_image,
                    image=image,
                    label=label,
                    output_dir=output_dir,
                    name=name,
                )
                future.add_done_callback(signal_error)
                futures.add(future)        
            if exception_event.is_set():
                break
    
    if exception[0] is not None:
        raise exception[0]        

    return [f.result() for f in futures]


def mock_encoder(x: jax.Array) -> jax.Array:
    b, h, w, c = x.shape
    y = x.reshape(b, h//8, 8, w//8, 8, c).mean((2, 4))[..., (0, 1, 2, 0)]
    return y * 3


def should_process(item: dict, output_dir: str) -> bool:
    label = item["label"]
    name = get_name(item)
    path = get_save_path(label, output_dir, name)
    exists = os.path.exists(path)
    return not exists


def main(
    *,
    batch_size: int, 
    image_size: int,
    num_workers: int, 
    save_threads: int,
    output_dir: str,
    mock_encoding: bool,
) -> None:
    imagenet = stream_imagenet_raw()
    encoder = load_encoder() if not mock_encoding else mock_encoder
    batch_processor = partial(process_imagenet_batch, size=image_size)
    for split in imagenet:
        split_dir = os.path.join(output_dir, split)
        filter_fn = partial(should_process, output_dir=split_dir)
        save_images_async(
            tqdm.tqdm(
                gen_codes(
                    dataset_iterator=iter(imagenet[split]),
                    batch_processor=batch_processor,
                    encoder=encoder,
                    batch_size=batch_size, 
                    num_workers=num_workers,
                    filter_fn=filter_fn,
                ), 
                desc=split,
            ),
            output_dir=split_dir, 
            max_workers=save_threads,
        )


if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--batch_size", type=int, default=96)
    parser.add_argument("--image_size", type=int, default=256)
    parser.add_argument("--num_workers", type=int, default=6)
    parser.add_argument("--save_threads", type=int, default=4)
    parser.add_argument("--output_dir", type=str, default="./data")
    parser.add_argument("--mock_encoding", action="store_true", default=False)
    kwargs = vars(parser.parse_args())
    main(**kwargs)