diff --git "a/huggingface_pixparse.txt" "b/huggingface_pixparse.txt"
new file mode 100644--- /dev/null
+++ "b/huggingface_pixparse.txt"
@@ -0,0 +1,2999 @@
+# File: pixparse-main/src/pixparse/app/eval.py
+import logging
+import os
+import json
+from dataclasses import dataclass, replace, field
+from typing import List
+import simple_parsing
+from simple_parsing import ArgumentParser
+import torch
+from pixparse.data import DataCfg, create_loader
+from pixparse.framework import TaskEval, TaskEvalCfg, DeviceEnv, Monitor, evaluate, setup_logging, random_seed
+from pixparse.utils.s3_utils import load_checkpoint_from_s3
+from pixparse.task.task_factory import TaskFactory
+from chug.webdataset import create_doc_anno_pipe, create_image_text_pipe
+from collections import OrderedDict
+_logger = logging.getLogger('eval')
+
+@dataclass
+class EvalCfg:
+    experiment: str = ''
+    output_dir: str = './output'
+    log_filename: str = 'out.log'
+    dataset_name: str = ''
+    s3_bucket: str = ''
+    checkpoint_path: str = ''
+    metrics_file_path: str = ''
+    task_name: str = ''
+    datasets: List[str] = field(default_factory=lambda : ['eval'])
+    seed: int = 42
+
+def eval(cfg: EvalCfg, task: TaskEval, eval_loaders: dict):
+    device_env = task.device_env
+    metrics = evaluate(task, eval_loaders)
+    with open(cfg.metrics_file_path, 'w') as f:
+        json.dump(metrics, f)
+parser = ArgumentParser(add_option_string_dash_variants=simple_parsing.DashVariant.DASH, argument_generation_mode=simple_parsing.ArgumentGenerationMode.BOTH, add_config_path_arg=True)
+parser.add_arguments(EvalCfg, dest='eval')
+parser.add_arguments(TaskEvalCfg, dest='task')
+parser.add_arguments(DataCfg, dest='data')
+
+def main():
+    args = parser.parse_args()
+    eval_cfg: EvalCfg = args.eval
+    data_cfg: DataCfg = args.data
+    device_env = DeviceEnv()
+    (task, task_cfg) = TaskFactory.create_task(task_name=eval_cfg.task_name, task_args=args.task, device_env=device_env, monitor=None)
+    random_seed(eval_cfg.seed, rank=device_env.global_rank)
+    _logger.info(f'Device env is {device_env}')
+    assert eval_cfg.output_dir is not None, f'output_dir is not provided. Stopping eval run.'
+    if device_env.is_primary():
+        log_path = os.path.join(eval_cfg.output_dir, eval_cfg.log_filename)
+        setup_logging(log_path)
+    monitor = Monitor(eval_cfg.experiment, output_dir=eval_cfg.output_dir, output_enabled=device_env.is_primary())
+    if eval_cfg.task_name not in ['donut_eval_ocr']:
+        checkpoint_path = eval_cfg.checkpoint_path
+        eval_cfg = replace(eval_cfg, checkpoint_path=checkpoint_path)
+        if eval_cfg.s3_bucket != '':
+            _logger.info('s3 bucket specified. Loading checkpoint from s3.')
+            checkpoint = load_checkpoint_from_s3(eval_cfg.s3_bucket, eval_cfg.checkpoint_path)
+        else:
+            assert os.path.isfile(checkpoint_path), f'Cannot find checkpoint {checkpoint_path}: File not found'
+            checkpoint = torch.load(eval_cfg.checkpoint_path)
+        if isinstance(checkpoint, OrderedDict):
+            state_dict = checkpoint
+        else:
+            state_dict = checkpoint['model']
+        checkpoint_name = eval_cfg.checkpoint_path.replace('/', '_').replace('.pt', '')
+        metrics_file_name = f'{checkpoint_name}-{eval_cfg.dataset_name}-metrics.json'
+        eval_state_dict = {k.replace('module.', ''): v for (k, v) in state_dict.items()}
+        task.resume_state_dict = eval_state_dict
+    else:
+        metrics_file_name = f'{eval_cfg.task_name}-{eval_cfg.dataset_name}-metrics.json'
+    eval_cfg.metrics_file_path = os.path.join(eval_cfg.output_dir, metrics_file_name)
+    if device_env.is_primary():
+        _logger.info(task_cfg)
+        _logger.info(eval_cfg)
+    loaders = {}
+    assert data_cfg.eval is not None, f'data_cfg.eval is not set.'
+    loaders['eval'] = create_loader(data_cfg.eval, is_train=False, collate_fn=task.collate_fn, image_preprocess=task.image_preprocess_eval, anno_preprocess=task.anno_preprocess_eval, image_fmt=task_cfg.model.image_encoder.image_fmt, world_size=device_env.world_size, local_rank=device_env.local_rank, create_decoder_pipe=create_image_text_pipe)
+    task.setup()
+    if device_env.is_primary():
+        _logger.info(task)
+    eval(eval_cfg, task, loaders)
+    task.end()
+if __name__ == '__main__':
+    main()
+
+# File: pixparse-main/src/pixparse/app/train.py
+import logging
+import os
+from dataclasses import dataclass, replace
+from datetime import datetime
+from typing import Dict, Optional
+import simple_parsing
+from simple_parsing import ArgumentParser
+import torch
+from pixparse.data import DataCfg, create_loader
+from pixparse.framework import DeviceEnv, Monitor, train_one_interval, evaluate, setup_logging, random_seed, TaskTrain, TaskTrainCfg
+from pixparse.utils.name_utils import clean_name
+from pixparse.utils.s3_utils import load_checkpoint_from_s3
+from pixparse.task import TaskFactory
+from chug.common import LoaderBundle
+from chug.webdataset import create_doc_anno_pipe
+from collections import OrderedDict
+_logger = logging.getLogger('train')
+
+@dataclass
+class TrainCfg:
+    experiment: Optional[str] = None
+    output_dir: str = './output'
+    log_filename: str = 'out.log'
+    s3_bucket: str = ''
+    resume: bool = False
+    checkpoint_path: str = ''
+    output_checkpoint_dir: Optional[str] = None
+    seed: int = 42
+    task_name: str = 'cruller_pretrain'
+    wandb: bool = False
+    wandb_project: str = 'unknown'
+    tensorboard: bool = False
+    log_eval_data: bool = False
+
+def train(cfg: TrainCfg, task: TaskTrain, loaders: Dict[str, LoaderBundle]):
+    device_env = task.device_env
+    train_loader = loaders['train']
+    for i in range(task.start_interval, task.num_intervals):
+        train_loader.set_interval(i)
+        train_one_interval(task, train_loader)
+        if device_env.is_primary():
+            checkpoint_dir = os.path.join(cfg.output_checkpoint_dir, cfg.experiment)
+            os.makedirs(checkpoint_dir, exist_ok=True)
+            torch.save(task.model.state_dict(), os.path.join(checkpoint_dir, f'checkpoint-{i}.pt'))
+parser = ArgumentParser(add_option_string_dash_variants=simple_parsing.DashVariant.DASH, argument_generation_mode=simple_parsing.ArgumentGenerationMode.BOTH, add_config_path_arg=True)
+parser.add_arguments(TrainCfg, dest='train')
+parser.add_arguments(TaskTrainCfg, dest='task')
+parser.add_arguments(DataCfg, dest='data')
+
+def main():
+    args = parser.parse_args()
+    train_cfg: TrainCfg = args.train
+    data_cfg: DataCfg = args.data
+    device_env = DeviceEnv()
+    (task, task_cfg) = TaskFactory.create_task(task_name=train_cfg.task_name, task_args=args.task, device_env=device_env, monitor=None)
+    random_seed(train_cfg.seed, rank=device_env.global_rank)
+    _logger.info(f'Device env is {device_env}')
+    if train_cfg.experiment is None:
+        model_name_safe = clean_name(task_cfg.model_name)
+        date_str = datetime.now().strftime('%Y%m%d-%H%M%S')
+        if device_env.world_size > 1:
+            date_str = device_env.broadcast_object(date_str)
+        experiment = '-'.join([date_str, f'task_{train_cfg.task_name}', f'model_{model_name_safe}', f"lr_{'{:.1e}'.format(task_cfg.opt.learning_rate)}", f'b_{data_cfg.train.batch_size}'])
+        train_cfg = replace(train_cfg, experiment=experiment)
+    resume_latest = False
+    experiment_path = os.path.join(train_cfg.output_dir, train_cfg.experiment)
+    log_path = None
+    if device_env.is_primary():
+        os.makedirs(experiment_path, exist_ok=True)
+        log_path = os.path.join(experiment_path, train_cfg.log_filename)
+        if os.path.exists(log_path) and (not resume_latest):
+            _logger.error('Error. Experiment already exists. Use --experiment {} to specify a new experiment.')
+            return -1
+    setup_logging(log_path)
+    task.monitor = Monitor(train_cfg.experiment, output_dir=experiment_path, wandb=train_cfg.wandb, wandb_project=train_cfg.wandb_project, tensorboard=train_cfg.tensorboard, output_enabled=device_env.is_primary())
+    if train_cfg.resume:
+        checkpoint_path = train_cfg.checkpoint_path
+        train_cfg = replace(train_cfg, checkpoint_path=checkpoint_path)
+        if train_cfg.s3_bucket != '':
+            _logger.info('s3 bucket specified. Loading checkpoint from s3.')
+            checkpoint = load_checkpoint_from_s3(train_cfg.s3_bucket, train_cfg.checkpoint_path)
+        else:
+            assert os.path.isfile(checkpoint_path), f'Cannot find checkpoint {checkpoint_path}: File not found'
+            checkpoint = torch.load(train_cfg.checkpoint_path)
+        if isinstance(checkpoint, OrderedDict):
+            state_dict = checkpoint
+        else:
+            state_dict = checkpoint['model']
+        task.state_dict = state_dict
+        task.resume = True
+    output_checkpoint_dir = train_cfg.output_checkpoint_dir or os.path.join(experiment_path, 'checkpoints')
+    os.makedirs(output_checkpoint_dir, exist_ok=True)
+    train_cfg = replace(train_cfg, output_checkpoint_dir=output_checkpoint_dir)
+    if device_env.is_primary():
+        _logger.info(task_cfg)
+        _logger.info(train_cfg)
+    loaders = {}
+    assert data_cfg.train is not None or data_cfg.eval is not None, f'Neither data_cfg.train nor data_cfg.eval are set.'
+    if data_cfg.train is not None:
+        loaders['train'] = create_loader(data_cfg.train, is_train=True, collate_fn=task.collate_fn, image_preprocess=task.image_preprocess_train, anno_preprocess=task.anno_preprocess_train, image_fmt=task_cfg.model.image_encoder.image_fmt, world_size=device_env.world_size, global_rank=device_env.global_rank, create_decoder_pipe=create_doc_anno_pipe)
+    task.train_setup(num_batches_per_interval=loaders['train'].num_batches)
+    if device_env.is_primary():
+        _logger.info(task)
+    train(train_cfg, task, loaders)
+if __name__ == '__main__':
+    main()
+
+# File: pixparse-main/src/pixparse/data/config.py
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+@dataclass
+class PreprocessCfg:
+    pass
+
+@dataclass
+class DatasetCfg:
+    source: str
+    num_samples: int
+    batch_size: int
+    split: str
+    format: str = 'webdataset'
+    num_workers: int = 4
+
+@dataclass
+class DataCfg:
+    train: Optional[DatasetCfg] = None
+    eval: Optional[DatasetCfg] = None
+
+# File: pixparse-main/src/pixparse/data/datasets_utils.py
+import json
+import os
+from ast import literal_eval
+import torch
+from datasets import load_dataset
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms
+from pixparse.utils.json_utils import json2token
+''
+
+class CustomVQADataset(Dataset):
+
+    def __init__(self, root_dir, split, transform=None):
+        self.extra_tokens = ['<s_answer>', '</s_answer>', '</s_question>', '<s_question>']
+        self.root_dir = root_dir
+        self.split = split
+        assert split in ['train', 'test', 'val'], 'split is not train, test or val.'
+        if split == 'test' or split == 'val':
+            json_path = os.path.join(root_dir, split, f'{split}_v1.0.json')
+        else:
+            json_path = os.path.join(root_dir, split, f'processed_{split}_v1.0.json')
+        assert os.path.isdir(self.root_dir), f"Can't find {root_dir}. Make sure you have DocVQA files locally."
+        assert os.path.isfile(json_path), f'{json_path} not found. Make sure you have the processed dataset.'
+        self.img_dir = os.path.join(root_dir, split)
+        with open(json_path, 'r') as f:
+            self.data_dict = json.load(f)
+        self.all_images = list(self.data_dict.keys())
+        self.transform = transform
+
+    def __len__(self):
+        if self.split == 'test' or self.split == 'val':
+            return len(self.data_dict['data'])
+        return len(self.all_images)
+
+    def __getitem__(self, index):
+        if self.split == 'test':
+            entry = self.data_dict['data'][index]
+            labels = '<s_question>' + entry['question'] + '</s_question>'
+            img_path = os.path.join(self.img_dir, entry['image'])
+            question_id = entry['questionId']
+            image_id = entry['image']
+        if self.split == 'val':
+            entry = self.data_dict['data'][index]
+            labels = {'question': entry['question'], 'answers': entry['answers']}
+            img_path = os.path.join(self.img_dir, entry['image'])
+            question_id = entry['questionId']
+            image_id = entry['image']
+        else:
+            image_id = self.all_images[index]
+            questions_and_answers = self.data_dict[image_id]
+            labels = questions_and_answers
+            img_path = os.path.join(self.img_dir, image_id)
+            question_id = -1
+        image = Image.open(img_path).convert('L')
+        if self.transform:
+            image = self.transform(image)
+        return {'image': image, 'labels': labels, 'image_id': image_id, 'question_id': question_id}
+
+class SafeDataset:
+
+    def __init__(self, original_dataset):
+        self.original_dataset = original_dataset
+
+    def __len__(self):
+        return len(self.original_dataset)
+
+    def __getitem__(self, idx):
+        try:
+            item = self.original_dataset[idx]
+            return item
+        except Exception as e:
+            return None
+
+def get_additional_tokens_from_dataset(all_special_tokens: list, dataset=None, dataset_id: str='naver-clova-ix/cord-v2') -> list:
+    if dataset_id == 'naver-clova-ix/cord-v2':
+
+        def collate_fn(batch):
+            text_inputs = [literal_eval(item['ground_truth'])['gt_parse'] for item in batch]
+            return {'label': text_inputs}
+        cord = load_dataset(dataset_id)
+        loader = DataLoader(cord['train'], batch_size=32, collate_fn=collate_fn)
+        new_special_tokens = []
+        for (i, batch) in enumerate(loader):
+            for text in batch['label']:
+                (_, batch_special_tokens) = json2token(text, all_special_tokens)
+                new_special_tokens += batch_special_tokens
+                new_special_tokens = list(set(new_special_tokens))
+    return new_special_tokens
+
+# File: pixparse-main/src/pixparse/data/loader.py
+from typing import Callable
+from chug import create_wds_loader, create_doc_anno_pipe
+from chug.common import LoaderBundle
+from datasets import VerificationMode
+from datasets import load_dataset
+from torch.utils.data import DataLoader, DistributedSampler
+from pixparse.data.datasets_utils import SafeDataset, CustomVQADataset
+from .config import DatasetCfg
+
+class GenericLoader(DataLoader):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.num_batches = len(self.dataset) // self.batch_size
+        if len(self.dataset) % self.batch_size != 0:
+            self.num_batches += 1
+
+def create_loader(cfg: DatasetCfg, is_train: bool, image_preprocess, anno_preprocess, collate_fn: Callable=None, image_key='pdf;tif;tiff;png;jpg;jpeg', image_fmt='L', start_interval: int=0, seed: int=0, world_size: int=1, global_rank: int=0, create_decoder_pipe: Callable=create_doc_anno_pipe):
+    decoder = create_decoder_pipe(image_preprocess=image_preprocess, anno_preprocess=anno_preprocess, image_key=image_key, image_fmt=image_fmt)
+    if cfg.format == 'webdataset':
+        loader = create_wds_loader(cfg.source, decoder, is_train=is_train, num_samples=cfg.num_samples, workers=cfg.num_workers, batch_size=cfg.batch_size, seed=seed, world_size=world_size)
+    elif cfg.format == 'hf_dataset':
+        if cfg.source == 'SinglePageDocVQA':
+            dataset = CustomVQADataset(root_dir=f'/fsx/pablo/.cache/{cfg.source}', split=cfg.split)
+        else:
+            dataset = load_dataset(cfg.source, verification_mode=VerificationMode.ALL_CHECKS)[cfg.split]
+        dataset = SafeDataset(dataset)
+        sampler = None
+        if world_size > 1:
+            sampler = DistributedSampler(dataset, rank=global_rank, shuffle=True, seed=seed, num_replicas=world_size, drop_last=True)
+        base_loader = DataLoader(dataset=dataset, collate_fn=collate_fn, sampler=sampler, batch_size=cfg.batch_size, num_workers=cfg.num_workers)
+        loader = LoaderBundle(loader=base_loader, num_batches=len(base_loader), num_samples=len(dataset), sampler=sampler)
+    return loader
+
+# File: pixparse-main/src/pixparse/data/preprocess.py
+import logging
+from typing import Callable
+import torch
+_logger = logging.getLogger(__name__)
+
+def preprocess_text_anno(anno, tokenizer: Callable, max_position_embeddings: int, task_start_token: str, prompt_end_token: str, ignore_id: int=-100, generator=None):
+    text = task_start_token + anno + tokenizer.eos_token
+    tokenizer_fn = lambda x: tokenizer(x, add_special_tokens=False, return_tensors='pt', max_length=max_position_embeddings, padding='max_length', truncation=True).input_ids[0]
+    text = tokenizer_fn(text)
+    target = text.clone()
+    target[target == tokenizer.pad_token_id] = ignore_id
+    prompt_end_token_id = tokenizer.convert_tokens_to_ids(prompt_end_token)
+    target[:torch.nonzero(target == prompt_end_token_id).sum() + 1] = ignore_id
+    return dict(text=[text], target=[target])
+
+def preprocess_ocr_anno(anno, tokenizer: Callable, max_position_embeddings: int, task_start_token: str, prompt_end_token: str, ignore_id: int=-100, generator=None):
+    if isinstance(anno, list):
+        _logger.warning('Old [id, {}] annotation form found, correcting...')
+        anno = anno[1]
+    num_pages = len(anno['pages'])
+    if not num_pages:
+        raise RuntimeError('Empty annotation. Skipping...')
+    tokenizer_fn = lambda x: tokenizer(x, add_special_tokens=False, return_tensors='pt', max_length=max_position_embeddings, padding='max_length', truncation=True).input_ids[0]
+    pad_token_id = tokenizer.pad_token_id
+    prompt_end_token_id = tokenizer.convert_tokens_to_ids(prompt_end_token)
+    current_index = generator.randint(0, num_pages - 1)
+    if not anno['pages'][current_index]['text']:
+        current_index = get_next_valid_page_index(current_index, num_pages, anno)
+    page_indices = []
+    text_pages = []
+    target_pages = []
+    n_wanted_pages = min(1, num_pages)
+    while len(text_pages) < n_wanted_pages:
+        anno_page = anno['pages'][current_index]
+        if not anno_page['text']:
+            raise RuntimeError('No text on page, skipping...')
+        text = '\n'.join(anno_page['text'])
+        orig_text = text
+        text = task_start_token + text + tokenizer.eos_token
+        text = tokenizer_fn(text)
+        target = text.clone()
+        target[target == pad_token_id] = ignore_id
+        target[:torch.nonzero(target == prompt_end_token_id).sum() + 1] = ignore_id
+        text_pages.append(text)
+        target_pages.append(target)
+        page_indices.append(current_index)
+        current_index = get_next_valid_page_index(current_index, num_pages, anno)
+    return (dict(text=text_pages, target=target_pages), dict(page_indices=page_indices, num_pages=num_pages, orig_text=orig_text))
+
+def get_next_valid_page_index(current_index: int, num_pages: int, anno: dict, retries: int=10):
+    for _ in range(retries):
+        current_index = (current_index + 1) % num_pages
+        anno_page = anno['pages'][current_index]
+        if anno_page['text']:
+            return current_index
+    raise RuntimeError(f'No non-empty page found after {retries} attempts')
+
+# File: pixparse-main/src/pixparse/data/transforms.py
+import random
+from typing import Tuple, Union
+import timm.data.transforms
+import torch
+import torchvision.transforms.functional as F
+from torchvision import transforms
+from PIL import Image, ImageOps, ImageFilter
+from timm.data.transforms import CenterCropOrPad
+from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+import numpy as np
+try:
+    import albumentations as alb
+    from albumentations.pytorch import ToTensorV2
+    has_albumentations = True
+except ImportError:
+    has_albumentations = False
+try:
+    import cv2
+    has_cv2 = True
+except ImportError:
+    has_cv2 = False
+
+def create_transforms(name, image_size, training=True, image_mean=IMAGENET_DEFAULT_MEAN, image_std=IMAGENET_DEFAULT_STD, interpolation: str='bicubic', crop_margin: bool=False, align_long_axis: bool=False, fill=255):
+    basic_args = dict(training=training, image_mean=image_mean, image_std=image_std)
+    adv_args = dict(interpolation=interpolation, crop_margin=crop_margin, align_long_axis=align_long_axis, fill=fill)
+    if name == 'better':
+        return better_transforms(image_size, **basic_args, **adv_args)
+    elif name == 'nougat':
+        return nougat_transforms(image_size, **basic_args, **adv_args)
+    else:
+        return legacy_transforms(image_size, **basic_args)
+
+def legacy_transforms(image_size, image_mean, image_std, training=False):
+    pp = transforms.Compose([transforms.Resize(image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.ToTensor(), transforms.Normalize(mean=image_mean, std=image_std)])
+    return pp
+
+def better_transforms(image_size, training=True, image_mean=IMAGENET_DEFAULT_MEAN, image_std=IMAGENET_DEFAULT_STD, interpolation='bicubic', crop_margin=False, align_long_axis=False, fill=255):
+    interpolation_mode = timm.data.transforms.str_to_interp_mode(interpolation)
+    pp = []
+    if crop_margin:
+        assert has_cv2, 'CV2 needed to use crop margin.'
+        pp += [CropMargin()]
+    if align_long_axis:
+        pp += [AlignLongAxis(image_size, interpolation=interpolation_mode)]
+    if training:
+        pp += [ResizeKeepRatio(image_size, longest=1, interpolation=interpolation, random_scale_prob=0.05, random_scale_range=(0.85, 1.04), random_aspect_prob=0.05, random_aspect_range=(0.9, 1.11)), transforms.RandomApply([Bitmap()], p=0.05), transforms.RandomApply([transforms.RandomChoice([Erosion(3), Dilation(3)])], p=0.02), transforms.RandomApply([transforms.RandomAffine(degrees=0, shear=(0, 3.0, -3, 0), interpolation=interpolation_mode, fill=fill)], p=0.05), transforms.RandomApply([transforms.RandomAffine(degrees=3, translate=(0, 0.04), interpolation=interpolation_mode, fill=fill)], p=0.05), transforms.RandomApply([transforms.ElasticTransform(alpha=50.0, sigma=120 * 0.1, interpolation=interpolation_mode, fill=fill)], p=0.05), transforms.RandomApply([transforms.ColorJitter(0.1, 0.1)], p=0.05), transforms.RandomApply([transforms.GaussianBlur(3, sigma=(0.1, 0.5))], p=0.05), RandomPad(image_size, fill=fill), transforms.CenterCrop(image_size)]
+    else:
+        pp += [ResizeKeepRatio(image_size, longest=1, interpolation=interpolation), CenterCropOrPad(image_size, fill=fill)]
+    pp += [transforms.ToTensor(), transforms.Normalize(image_mean, image_std)]
+    return transforms.Compose(pp)
+
+def nougat_transforms(image_size, training=True, image_mean=IMAGENET_DEFAULT_MEAN, image_std=IMAGENET_DEFAULT_STD, align_long_axis=False, interpolation='bicubic', fill=255, crop_margin=False):
+    assert has_albumentations, 'Albumentations and CV2 needed to use nougat transforms.'
+    if interpolation == 'bilinear':
+        interpolation_mode = 1
+    else:
+        interpolation_mode = 2
+    tv_pp = []
+    alb_pp = []
+    if crop_margin:
+        tv_pp += [CropMargin()]
+    if align_long_axis:
+        tv_pp += [AlignLongAxis(image_size)]
+    if training:
+        tv_pp += [ResizeKeepRatio(image_size, longest=1, interpolation=interpolation), RandomPad(image_size, fill=fill)]
+        alb_pp += [BitmapAlb(p=0.05), alb.OneOf([ErosionAlb((2, 3)), DilationAlb((2, 3))], p=0.02), alb.Affine(shear={'x': (0, 3), 'y': (-3, 0)}, cval=(255, 255, 255), p=0.03), alb.ShiftScaleRotate(shift_limit_x=(0, 0.04), shift_limit_y=(0, 0.03), scale_limit=(-0.15, 0.03), rotate_limit=2, border_mode=0, interpolation=interpolation_mode, value=fill, p=0.03), alb.GridDistortion(distort_limit=0.05, border_mode=0, interpolation=interpolation_mode, value=fill, p=0.04), alb.Compose([alb.Affine(translate_px=(0, 5), always_apply=True, cval=(255, 255, 255)), alb.ElasticTransform(p=1, alpha=50, sigma=120 * 0.1, alpha_affine=120 * 0.01, border_mode=0, value=fill)], p=0.04), alb.RandomBrightnessContrast(0.1, 0.1, True, p=0.03), alb.ImageCompression(95, p=0.07), alb.GaussNoise(20, p=0.08), alb.GaussianBlur((3, 3), p=0.03)]
+    else:
+        tv_pp += [ResizeKeepRatio(image_size, longest=1, interpolation=interpolation), CenterCropOrPad(image_size, fill=fill)]
+    alb_pp += [alb.Normalize(image_mean, image_std), alb.pytorch.ToTensorV2()]
+    tv_pp += [alb_wrapper(alb.Compose(alb_pp))]
+    return transforms.Compose(tv_pp)
+
+def alb_wrapper(transform):
+
+    def f(im):
+        return transform(image=np.asarray(im))['image']
+    return f
+
+class CropMargin:
+
+    def __init__(self):
+        pass
+
+    def __call__(self, img):
+        if isinstance(img, torch.Tensor):
+            assert False
+        else:
+            data = np.array(img.convert('L'))
+            data = data.astype(np.uint8)
+            max_val = data.max()
+            min_val = data.min()
+            if max_val == min_val:
+                return img
+            data = (data - min_val) / (max_val - min_val) * 255
+            gray = 255 * (data < 200).astype(np.uint8)
+            coords = cv2.findNonZero(gray)
+            (a, b, w, h) = cv2.boundingRect(coords)
+            return img.crop((a, b, w + a, h + b))
+
+class AlignLongAxis:
+
+    def __init__(self, input_size, interpolation=transforms.InterpolationMode.BICUBIC):
+        self.input_size = input_size
+        self.interpolation = interpolation
+
+    def __call__(self, img):
+        is_tensor = isinstance(img, torch.Tensor)
+        (img_height, img_width) = img.shape[-2:] if is_tensor else (img.height, img.width)
+        if self.input_size[0] > self.input_size[1] and img_width > img_height or (self.input_size[0] < self.input_size[1] and img_width < img_height):
+            img = F.rotate(img, angle=-90, expand=True, interpolation=self.interpolation)
+        return img
+
+class RandomPad:
+
+    def __init__(self, input_size, fill=0):
+        self.input_size = input_size
+        self.fill = fill
+
+    @staticmethod
+    def get_params(img, input_size):
+        (width, height) = F.get_image_size(img)
+        delta_width = max(input_size[1] - width, 0)
+        delta_height = max(input_size[0] - height, 0)
+        pad_left = random.randint(0, delta_width)
+        pad_top = random.randint(0, delta_height)
+        pad_right = delta_width - pad_left
+        pad_bottom = delta_height - pad_top
+        return (pad_left, pad_top, pad_right, pad_bottom)
+
+    def __call__(self, img):
+        padding = self.get_params(img, self.input_size)
+        img = F.pad(img, padding, self.fill)
+        return img
+
+class ResizeKeepRatio:
+
+    def __init__(self, size, longest=0.0, interpolation='bilinear', random_scale_prob=0.0, random_scale_range=(0.85, 1.05), random_aspect_prob=0.0, random_aspect_range=(0.9, 1.11)):
+        if isinstance(size, (list, tuple)):
+            self.size = tuple(size)
+        else:
+            self.size = (size, size)
+        self.interpolation = timm.data.transforms.str_to_interp_mode(interpolation)
+        self.longest = float(longest)
+        self.random_scale_prob = random_scale_prob
+        self.random_scale_range = random_scale_range
+        self.random_aspect_prob = random_aspect_prob
+        self.random_aspect_range = random_aspect_range
+
+    @staticmethod
+    def get_params(img, target_size, longest, random_scale_prob=0.0, random_scale_range=(0.85, 1.05), random_aspect_prob=0.0, random_aspect_range=(0.9, 1.11)):
+        source_size = img.size[::-1]
+        (h, w) = source_size
+        (target_h, target_w) = target_size
+        ratio_h = h / target_h
+        ratio_w = w / target_w
+        ratio = max(ratio_h, ratio_w) * longest + min(ratio_h, ratio_w) * (1.0 - longest)
+        if random_scale_prob > 0 and random.random() < random_scale_prob:
+            ratio_factor = random.uniform(random_scale_range[0], random_scale_range[1])
+            ratio_factor = (ratio_factor, ratio_factor)
+        else:
+            ratio_factor = (1.0, 1.0)
+        if random_aspect_prob > 0 and random.random() < random_aspect_prob:
+            aspect_factor = random.uniform(random_aspect_range[0], random_aspect_range[1])
+            ratio_factor = (ratio_factor[0] / aspect_factor, ratio_factor[1] * aspect_factor)
+        size = [round(x * f / ratio) for (x, f) in zip(source_size, ratio_factor)]
+        return size
+
+    def __call__(self, img):
+        size = self.get_params(img, self.size, self.longest, self.random_scale_prob, self.random_scale_range, self.random_aspect_prob, self.random_aspect_range)
+        img = F.resize(img, size, self.interpolation)
+        return img
+
+    def __repr__(self):
+        interpolate_str = timm.data.transforms.interp_mode_to_str(self.interpolation)
+        format_string = self.__class__.__name__ + '(size={0}'.format(self.size)
+        format_string += f', interpolation={interpolate_str})'
+        format_string += f', longest={self.longest:.3f})'
+        return format_string
+
+class Bitmap:
+
+    def __init__(self, threshold=200):
+        self.lut = [0 if i < threshold else i for i in range(256)]
+
+    def __call__(self, img):
+        if img.mode == 'RGB' and len(self.lut) == 256:
+            lut = self.lut + self.lut + self.lut
+        else:
+            lut = self.lut
+        return img.point(lut)
+
+class Erosion:
+
+    def __init__(self, scale=3):
+        super().__init__()
+        if type(scale) is tuple or type(scale) is list:
+            assert len(scale) == 2
+            self.scale = scale
+        else:
+            self.scale = (scale, scale)
+
+    @staticmethod
+    def get_params(scale):
+        if type(scale) is tuple or type(scale) is list:
+            assert len(scale) == 2
+            scale = random.choice(scale)
+        return scale
+
+    def __call__(self, img):
+        kernel_size = self.get_params(self.scale)
+        if isinstance(img, torch.Tensor):
+            padding = kernel_size // 2
+            img = -torch.nn.functional.max_pool2d(-img, kernel_size=kernel_size, padding=padding)
+        elif isinstance(img, Image.Image):
+            img = img.filter(ImageFilter.MinFilter(kernel_size))
+        return img
+
+class Dilation:
+
+    def __init__(self, scale=3):
+        super().__init__()
+        self.scale = scale
+
+    @staticmethod
+    def get_params(scale):
+        if type(scale) is tuple or type(scale) is list:
+            assert len(scale) == 2
+            scale = random.choice(scale)
+        return scale
+
+    def __call__(self, img):
+        kernel_size = self.get_params(self.scale)
+        if isinstance(img, torch.Tensor):
+            padding = kernel_size // 2
+            img = torch.nn.functional.max_pool2d(img, kernel_size=kernel_size, padding=padding)
+        elif isinstance(img, Image.Image):
+            img = img.filter(ImageFilter.MaxFilter(kernel_size))
+        return img
+if has_albumentations:
+
+    class ErosionAlb(alb.ImageOnlyTransform):
+
+        def __init__(self, scale, always_apply=False, p=0.5):
+            super().__init__(always_apply=always_apply, p=p)
+            if type(scale) is tuple or type(scale) is list:
+                assert len(scale) == 2
+                self.scale = scale
+            else:
+                self.scale = (scale, scale)
+
+        def apply(self, img, **params):
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, tuple(np.random.randint(self.scale[0], self.scale[1], 2)))
+            img = cv2.erode(img, kernel, iterations=1)
+            return img
+
+    class DilationAlb(alb.ImageOnlyTransform):
+
+        def __init__(self, scale, always_apply=False, p=0.5):
+            super().__init__(always_apply=always_apply, p=p)
+            if type(scale) is tuple or type(scale) is list:
+                assert len(scale) == 2
+                self.scale = scale
+            else:
+                self.scale = (scale, scale)
+
+        def apply(self, img, **params):
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, tuple(np.random.randint(self.scale[0], self.scale[1], 2)))
+            img = cv2.dilate(img, kernel, iterations=1)
+            return img
+
+    class BitmapAlb(alb.ImageOnlyTransform):
+
+        def __init__(self, value=0, lower=200, always_apply=False, p=0.5):
+            super().__init__(always_apply=always_apply, p=p)
+            self.lower = lower
+            self.value = value
+
+        def apply(self, img, **params):
+            img = img.copy()
+            img[img < self.lower] = self.value
+            return img
+
+# File: pixparse-main/src/pixparse/framework/config.py
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+
+@dataclass
+class OptimizationCfg:
+    optimizer: str = 'adamw'
+    scheduler: str = 'cosine'
+    learning_rate: float = 0.0005
+    warmup_learning_rate: float = 0.0
+    weight_decay: float = 0.02
+    eps: float = 1e-06
+    clip_grad_value: Optional[float] = None
+    clip_grad_mode: Optional[str] = None
+    grad_accum_steps: int = 1
+    momentum: Optional[float] = None
+    betas: Optional[Tuple[float, float]] = None
+    layer_decay: Optional[float] = None
+
+@dataclass
+class TaskTrainCfg:
+    num_intervals: int = 100
+    num_warmup_intervals: int = 5
+    eval_frequency: int = 1000
+    opt: OptimizationCfg = field(default_factory=OptimizationCfg)
+    dtype: Optional[str] = None
+    amp: bool = True
+    model_name: str = ''
+
+@dataclass
+class TaskEvalCfg:
+    dtype: Optional[str] = None
+    amp: bool = True
+    model_name: str = ''
+    model_state_dict: dict = field(default_factory=dict)
+
+# File: pixparse-main/src/pixparse/framework/device.py
+""""""
+import os
+from dataclasses import dataclass, field, InitVar
+from enum import Enum
+from typing import Union, Optional, List, Tuple
+import torch
+import torch.distributed as dist
+
+def is_distributed_env():
+    if 'WORLD_SIZE' in os.environ:
+        return int(os.environ['WORLD_SIZE']) > 1
+    if 'SLURM_NTASKS' in os.environ:
+        return int(os.environ['SLURM_NTASKS']) > 1
+    return False
+
+def world_info_from_env():
+    local_rank = 0
+    for v in ('LOCAL_RANK', 'MPI_LOCALRANKID', 'SLURM_LOCALID', 'OMPI_COMM_WORLD_LOCAL_RANK'):
+        if v in os.environ:
+            local_rank = int(os.environ[v])
+            break
+    global_rank = 0
+    for v in ('RANK', 'PMI_RANK', 'SLURM_PROCID', 'OMPI_COMM_WORLD_RANK'):
+        if v in os.environ:
+            global_rank = int(os.environ[v])
+            break
+    world_size = 1
+    for v in ('WORLD_SIZE', 'PMI_SIZE', 'SLURM_NTASKS', 'OMPI_COMM_WORLD_SIZE'):
+        if v in os.environ:
+            world_size = int(os.environ[v])
+            break
+    return (local_rank, global_rank, world_size)
+
+class DeviceEnvType(Enum):
+    CPU = 'cpu'
+    CUDA = 'cuda'
+    XLA = 'xla'
+
+@dataclass
+class DeviceEnv:
+    init_device_type: InitVar[Optional[str]] = None
+    init_device_index: InitVar[Optional[int]] = None
+    init_dist_backend: InitVar[str] = 'nccl'
+    init_dist_url: InitVar[str] = 'env://'
+    device: torch.device = field(init=False)
+    world_size: Optional[int] = None
+    local_rank: Optional[int] = None
+    global_rank: Optional[int] = None
+
+    def is_global_primary(self):
+        return self.global_rank == 0
+
+    def is_local_primary(self):
+        return self.local_rank == 0
+
+    def is_primary(self, local=False):
+        return self.is_local_primary() if local else self.is_global_primary()
+
+    def __post_init__(self, init_device_type: Optional[str], init_device_index: Optional[int], init_dist_backend: str, init_dist_url: str):
+        assert torch.cuda.device_count()
+        torch.backends.cudnn.benchmark = True
+        torch.backends.cuda.matmul.allow_tf32 = True
+        (init_local_rank, init_global_rank, init_world_size) = world_info_from_env()
+        if init_world_size > 1:
+            assert init_device_index is None
+            self.local_rank = int(init_local_rank)
+            is_slurm = 'SLURM_PROCID' in os.environ
+            if 'SLURM_PROCID' in os.environ:
+                torch.distributed.init_process_group(backend=init_dist_backend, init_method=init_dist_url, world_size=init_world_size, rank=init_global_rank)
+            else:
+                torch.distributed.init_process_group(backend=init_dist_backend, init_method=init_dist_url)
+            self.world_size = torch.distributed.get_world_size()
+            self.global_rank = torch.distributed.get_rank()
+            if is_slurm:
+                assert self.world_size == init_world_size
+                assert self.global_rank == init_global_rank
+            self.device = torch.device('cuda:%d' % self.local_rank)
+            torch.cuda.set_device(self.local_rank)
+        else:
+            self.device = torch.device('cuda' if init_device_index is None else f'cuda:{init_device_index}')
+            self.local_rank = 0
+            self.world_size = 1
+            self.global_rank = 0
+
+    def broadcast_object(self, obj, src=0):
+        if self.global_rank == src:
+            objects = [obj]
+        else:
+            objects = [None]
+        dist.broadcast_object_list(objects, src=src)
+        return objects[0]
+
+    def all_gather_object(self, obj, dst=0):
+        objects = [None for _ in range(self.world_size)]
+        dist.all_gather_object(objects, obj)
+        return objects
+
+# File: pixparse-main/src/pixparse/framework/eval.py
+from .task import TaskEval
+
+def evaluate(task: TaskEval, loaders):
+    metrics = dict()
+    authorized_loaders = task.prepare_for_evaluation(loaders)
+    for (key, loader) in authorized_loaders.items():
+        metrics[key] = dict()
+        for (index_batch, sample) in enumerate(loader.loader):
+            metrics[key][index_batch] = task.step(sample)
+        if hasattr(task, 'average_metrics'):
+            averaged_metrics = task.average_metrics(metrics[key])
+            metrics[key] = {}
+            metrics[key]['average'] = averaged_metrics
+    return metrics
+
+# File: pixparse-main/src/pixparse/framework/logger.py
+import logging
+
+def setup_logging(log_file, debug=False, include_host=False, set_all_loggers=False):
+    level = logging.DEBUG if debug else logging.INFO
+    if include_host:
+        import socket
+        hostname = socket.gethostname()
+        formatter = logging.Formatter(f'%(asctime)s |  {hostname} | %(levelname)s | %(message)s', datefmt='%Y-%m-%d,%H:%M:%S')
+    else:
+        formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(message)s', datefmt='%Y-%m-%d,%H:%M:%S')
+    logging.root.setLevel(level)
+    if set_all_loggers:
+        loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
+        for logger in loggers:
+            logger.setLevel(level)
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(formatter)
+    logging.root.addHandler(stream_handler)
+    if log_file:
+        file_handler = logging.FileHandler(filename=log_file)
+        file_handler.setFormatter(formatter)
+        logging.root.addHandler(file_handler)
+
+# File: pixparse-main/src/pixparse/framework/monitor.py
+import csv
+import logging
+import os
+from collections import OrderedDict
+from typing import Optional, Tuple, Dict, Union
+import torch
+from torch.utils.tensorboard.summary import image
+_logger = logging.getLogger(__name__)
+try:
+    from torch.utils.tensorboard import SummaryWriter
+    HAS_TB = True
+except ImportError as e:
+    HAS_TB = False
+try:
+    import wandb
+    HAS_WANDB = True
+except ImportError:
+    HAS_WANDB = False
+
+def summary_row_dict(results, index=None, index_name='epoch'):
+    assert isinstance(results, dict)
+    row_dict = OrderedDict()
+    if index is not None:
+        row_dict[index_name] = index
+    if not results:
+        return row_dict
+    if isinstance(next(iter(results.values())), dict):
+        for (p, pr) in results.items():
+            assert isinstance(pr, dict)
+            row_dict.update([('_'.join([p, k]), v) for (k, v) in pr.items()])
+    else:
+        row_dict.update(results)
+    return row_dict
+
+class SummaryCsv:
+
+    def __init__(self, output_dir, filename='summary.csv'):
+        self.output_dir = output_dir
+        self.filename = os.path.join(output_dir, filename)
+        self.needs_header = not os.path.exists(self.filename)
+
+    def update(self, row_dict):
+        with open(self.filename, mode='a') as cf:
+            dw = csv.DictWriter(cf, fieldnames=row_dict.keys())
+            if self.needs_header:
+                dw.writeheader()
+                self.needs_header = False
+            dw.writerow(row_dict)
+_sci_keys = {'lr'}
+
+def _add_kwargs(text_update, name_map=None, **kwargs):
+
+    def _to_str(key, val):
+        if isinstance(val, float):
+            if key.lower() in _sci_keys:
+                return f'{key}: {val:.3e} '
+            else:
+                return f'{key}: {val:.4f}'
+        else:
+            return f'{key}: {val}'
+
+    def _map_name(key, name_map, capitalize=False):
+        if name_map is None:
+            if capitalize:
+                return key.capitalize() if not key.isupper() else key
+            else:
+                return key
+        return name_map.get(key, None)
+    for (k, v) in kwargs.items():
+        if isinstance(v, dict):
+            for (kk, vv) in v.items():
+                name = _map_name(kk, name_map)
+                if not name:
+                    continue
+                text_update += [_to_str(kk, vv)]
+        else:
+            name = _map_name(k, name_map)
+            if not name:
+                continue
+            text_update += [_to_str(name, v)]
+
+class Monitor:
+
+    def __init__(self, experiment_name=None, output_dir=None, logger=None, hparams=None, wandb=False, wandb_project='unknown', wandb_dir='wandb', tensorboard=False, tensorboard_dir='tensorboard', output_enabled=True, log_eval_data=False):
+        self.output_dir = output_dir
+        self.logger = logger or logging.getLogger('log')
+        hparams = hparams or {}
+        if output_dir is not None:
+            self.csv_writer = SummaryCsv(output_dir=output_dir)
+        else:
+            self.csv_writer = None
+        self.tensorboard = None
+        if tensorboard:
+            assert HAS_TB
+            self.tensorboard = SummaryWriter(log_dir=os.path.join(self.output_dir, tensorboard_dir))
+        self.wandb = None
+        if wandb:
+            if HAS_WANDB:
+                dir_ = os.path.join(self.output_dir, wandb_dir)
+                self.wandb = wandb.init(project=wandb_project, name=experiment_name, config=hparams, dir=dir_)
+                _logger.info(f'Wandb found. Metrics are being logged to {dir_}')
+            else:
+                _logger.warning("You've requested to log metrics to wandb but package not found. Metrics not being logged to wandb, try `pip install wandb`")
+        self.output_enabled = output_enabled
+        self.log_eval_data = log_eval_data
+
+    def log_step(self, phase: str, step_idx: int, step_end_idx: Optional[int]=None, interval: Optional[int]=None, loss: Optional[float]=None, rate: Optional[Union[float, Tuple[float, float]]]=None, learning_rate: Optional[float]=None, phase_suffix: str='', metrics: dict=None, eval_data: dict=None, **kwargs):
+        if not self.output_enabled:
+            return
+        if 'num_steps' in kwargs:
+            step_end_idx = max(0, kwargs.pop('num_steps') - 1)
+        phase_title = f'{phase.capitalize()} ({phase_suffix})' if phase_suffix else f'{phase.capitalize()}:'
+        progress = 100.0 * step_idx / step_end_idx if step_end_idx else 0.0
+        rate_str = ''
+        if isinstance(rate, (tuple, list)):
+            rate_str = f'Rate: {rate[0]:.2f}/s ({rate[1]:.2f}/s)'
+        elif rate is not None:
+            rate_str = f'Rate: {rate:.2f}/s'
+        text_update = [phase_title, f'{interval}' if interval is not None else None, f'[{step_idx}]' if step_end_idx is None else None, f'[{step_idx}/{step_end_idx} ({progress:>3.0f}%)]' if step_end_idx is not None else None, rate_str, f'loss: {loss:.5f}' if loss is not None else None, f'lr: {learning_rate:.5f}' if learning_rate is not None else None]
+        _add_kwargs(text_update, **kwargs)
+        log_str = ' '.join((item for item in text_update if item))
+        self.logger.info(log_str)
+        if self.tensorboard is not None:
+            if metrics is not None:
+                for (metric_category, metric_items) in metrics.items():
+                    for (metric_name, metric_value) in metric_items.items():
+                        self.tensorboard.add_scalar('/'.join([metric_category, metric_name, phase_title]), metric_value, step_idx)
+            if eval_data is not None and self.log_eval_data:
+                for (eval_data_category, eval_data_triplet) in eval_data.items():
+                    if eval_data_category == 'ocr_reconstruction_data':
+                        image_tag = '/'.join([eval_data_category, 'image', phase_title])
+                        self.tensorboard._get_file_writer().add_summary(image(image_tag, eval_data_triplet['image'], dataformats='CHW'), step_idx)
+                        self.tensorboard.add_text('/'.join([eval_data_category, 'original_text', phase_title]), eval_data_triplet['original_text'], step_idx)
+                        self.tensorboard.add_text('/'.join([eval_data_category, 'reconstructed_text', phase_title]), eval_data_triplet['reconstructed_text'], step_idx)
+            if loss is not None:
+                self.tensorboard.add_scalar('/'.join(['Loss', phase_title]), loss, step_idx)
+            if learning_rate is not None:
+                self.tensorboard.add_scalar('/'.join(['Learning Rate', phase_title]), loss, step_idx)
+            for (k, v) in kwargs.items():
+                self.tensorboard.add_scalar('/'.join([k, phase_title]), v, step_idx)
+        if self.wandb is not None:
+            wandb_log = dict(**kwargs)
+            if loss:
+                wandb_log['loss'] = loss
+            if learning_rate:
+                wandb_log['learning_rate'] = learning_rate
+
+    def log_phase(self, phase: str='eval', interval: Optional[int]=None, name_map: Optional[dict]=None, **kwargs):
+        if not self.output_enabled:
+            return
+        title = [f'{phase.capitalize()}', f'interval {interval}' if interval is not None else None, 'completed. ']
+        title_str = ' '.join((i for i in title if i))
+        results = []
+        _add_kwargs(results, name_map=name_map, **kwargs)
+        log_str = title_str + ', '.join((item for item in results if item))
+        self.logger.info(log_str)
+
+    def write_summary(self, results: Dict, index: Optional[Union[int, str]]=None, index_name: str='interval'):
+        if not self.output_enabled:
+            return
+        row_dict = summary_row_dict(index=index, index_name=index_name, results=results)
+        if self.csv_writer:
+            self.csv_writer.update(row_dict)
+        if self.wandb is not None:
+            wandb.log(row_dict)
+        if self.tensorboard:
+            pass
+
+# File: pixparse-main/src/pixparse/framework/task.py
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+from .config import TaskTrainCfg, TaskEvalCfg
+from .device import DeviceEnv
+from .monitor import Monitor
+
+class Task:
+
+    def __init__(self, device_env: DeviceEnv, monitor: Monitor=None):
+        self.device_env = device_env
+        self.monitor = monitor
+
+class TaskEval(Task):
+
+    def __init__(self, cfg: TaskEvalCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(device_env=device_env, monitor=monitor)
+
+    def collate_fn(self, batch):
+        pass
+
+    def setup(self, *args, **kwargs):
+        pass
+
+    def prepare_for_evaluation(self):
+        pass
+
+    def step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
+    def end(self):
+        pass
+
+class TaskTrain(Task):
+
+    def __init__(self, cfg: TaskTrainCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(device_env=device_env, monitor=monitor)
+        self.num_intervals = cfg.num_intervals
+        self.num_warmup_intervals = cfg.num_warmup_intervals
+        self.eval_frequency = cfg.eval_frequency
+        self.num_steps_per_interval = None
+        self.start_interval = 0
+        self.step = 0
+        self.batch_idx = 0
+        self.interval_idx = 0
+        self.interval_batch_idx = 0
+        self.optimizer = None
+        self.scheduler = None
+        self.scaler = None
+        self.autocast = None
+
+    def collate_fn(self, batch):
+        pass
+
+    def train_setup(self, *args, **kwargs):
+        pass
+
+    def train_interval_start(self):
+        pass
+
+    def train_interval_end(self):
+        pass
+
+    def train_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
+    def eval_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
+    def get_current_lr(self):
+        lrl = [param_group['lr'] for param_group in self.optimizer.param_groups]
+        lr = sum(lrl) / len(lrl)
+        return lr
+
+# File: pixparse-main/src/pixparse/framework/train.py
+from .task import TaskTrain
+import torch
+import os
+
+def train_one_interval(task: TaskTrain, loader):
+    task.train_interval_start()
+    for (i, sample) in enumerate(loader.loader):
+        task.train_step(sample)
+    task.train_interval_end()
+
+# File: pixparse-main/src/pixparse/models/config.py
+import copy
+import re
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+from simple_parsing.helpers import Serializable
+from pixparse.utils.name_utils import _natural_key, clean_name
+_MODEL_CONFIG_PATHS = [Path(__file__).parent / f'configs/']
+_MODEL_CONFIGS = {}
+
+@dataclass
+class ImageEncoderCfg(Serializable):
+    name: str = 'vit_base_patch16_224'
+    image_fmt: str = 'L'
+    image_size: Optional[Tuple[int, int]] = (576, 448)
+    pretrained: bool = True
+
+@dataclass
+class TextDecoderCfg(Serializable):
+    name: str = 'facebook/bart-base'
+    pretrained: bool = True
+    num_decoder_layers: Optional[int] = 4
+    max_length: Optional[int] = 1024
+    pad_token_id: Optional[int] = None
+
+@dataclass
+class ModelCfg(Serializable):
+    image_encoder: ImageEncoderCfg = field(default_factory=ImageEncoderCfg)
+    text_decoder: TextDecoderCfg = field(default_factory=TextDecoderCfg)
+
+def _scan_model_configs():
+    global _MODEL_CONFIGS
+    config_ext = ('.json',)
+    config_files = []
+    for config_path in _MODEL_CONFIG_PATHS:
+        if config_path.is_file() and config_path.suffix in config_ext:
+            config_files.append(config_path)
+        elif config_path.is_dir():
+            for ext in config_ext:
+                config_files.extend(config_path.glob(f'*{ext}'))
+    for cf in config_files:
+        model_cfg = ModelCfg.load(cf)
+        _MODEL_CONFIGS[cf.stem] = model_cfg
+    _MODEL_CONFIGS = {k: v for (k, v) in sorted(_MODEL_CONFIGS.items(), key=lambda x: _natural_key(x[0]))}
+_scan_model_configs()
+
+def list_models():
+    return list(_MODEL_CONFIGS.keys())
+
+def get_model_config(model_name):
+    model_name = clean_name(model_name)
+    cfg = _MODEL_CONFIGS.get(model_name, None)
+    return copy.deepcopy(cfg)
+
+# File: pixparse-main/src/pixparse/models/cruller.py
+import torch.nn as nn
+from .config import ModelCfg
+from .image_encoder_timm import ImageEncoderTimm
+from .text_decoder_hf import TextDecoderHf
+
+class Cruller(nn.Module):
+
+    def __init__(self, cfg: ModelCfg):
+        super().__init__()
+        self.image_encoder = ImageEncoderTimm(cfg.image_encoder)
+        self.text_decoder = TextDecoderHf(cfg.text_decoder)
+
+    def forward(self, image_input, text_input):
+        encoder_output = self.image_encoder(image_input)
+        decoder_output = self.text_decoder(text_input, encoder_hidden_states=encoder_output, return_dict=True)
+        return decoder_output
+
+# File: pixparse-main/src/pixparse/models/image_encoder_timm.py
+import timm
+from torch import nn as nn
+from pixparse.models.config import ImageEncoderCfg
+
+def create_image_encoder(cfg: ImageEncoderCfg) -> nn.Module:
+    assert cfg.name
+    extra_kwargs = {}
+    if cfg.image_size is not None:
+        extra_kwargs['img_size'] = cfg.image_size
+    assert cfg.image_fmt in ('L', 'RGB')
+    model = timm.create_model(cfg.name, pretrained=cfg.pretrained, in_chans=1 if cfg.image_fmt == 'L' else 3, num_classes=0, global_pool='', **extra_kwargs)
+    return model
+
+class ImageEncoderTimm(nn.Module):
+
+    def __init__(self, cfg: ImageEncoderCfg):
+        super().__init__()
+        self.trunk = create_image_encoder(cfg)
+        self.pool = None
+        self.head = None
+
+    def forward(self, x):
+        x = self.trunk(x)
+        if self.pool is not None:
+            x = self.pool(x)
+        if self.head is not None:
+            x = self.head(x)
+        return x
+
+# File: pixparse-main/src/pixparse/models/text_decoder_hf.py
+from typing import Optional
+import torch
+import transformers
+from torch import nn as nn
+from pixparse.models.config import TextDecoderCfg
+
+def create_text_decoder(cfg: TextDecoderCfg) -> transformers.BartForCausalLM:
+    assert cfg.name
+    config = transformers.AutoConfig.from_pretrained(cfg.name)
+    config.add_cross_attention = True
+    if False:
+        config.is_encoder_decoder = False
+        config.scale_embedding = True
+        config.add_final_layer_norm = True
+    if cfg.num_decoder_layers is not None:
+        config.decoder_layers = cfg.num_decoder_layers
+    if cfg.max_length is not None:
+        config.max_position_embeddings = cfg.max_length
+    if cfg.pretrained:
+        model = transformers.AutoModelForCausalLM.from_pretrained(cfg.name, config=config)
+    else:
+        model = transformers.AutoModelForCausalLM.from_config(config)
+    return model
+
+class TextDecoderHf(nn.Module):
+
+    def __init__(self, cfg: TextDecoderCfg):
+        super().__init__()
+        self.trunk = create_text_decoder(cfg)
+        self.prepare_inputs_for_generation = self.prepare_inputs_for_inference
+
+    def prepare_inputs_for_inference(self, input_ids: torch.Tensor, encoder_outputs: torch.Tensor, pad_token_id: int, past_key_values=None, past=None, use_cache: bool=None, attention_mask: torch.Tensor=None):
+        if past is not None:
+            past_key_values = past
+        attention_mask = input_ids.ne(pad_token_id).long()
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+        output = {'input_ids': input_ids, 'attention_mask': attention_mask, 'past_key_values': past_key_values, 'use_cache': use_cache, 'encoder_hidden_states': encoder_outputs}
+        return output
+
+    def forward(self, input_ids, attention_mask: Optional[torch.Tensor]=None, encoder_hidden_states: Optional[torch.Tensor]=None, past_key_values: Optional[torch.Tensor]=None, use_cache: bool=None, output_attentions: Optional[torch.Tensor]=None, output_hidden_states: Optional[torch.Tensor]=None, return_dict: bool=None):
+        output = self.trunk(input_ids=input_ids, attention_mask=attention_mask, encoder_hidden_states=encoder_hidden_states, past_key_values=past_key_values, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
+        return output
+
+# File: pixparse-main/src/pixparse/task/__init__.py
+from .task_cruller_pretrain import TaskCrullerPretrain, TaskCrullerPretrainCfg
+from .task_cruller_finetune_RVLCDIP import TaskCrullerFinetuneRVLCDIP, TaskCrullerFinetuneRVLCDIPCfg
+from .task_cruller_finetune_CORD import TaskCrullerFinetuneCORD, TaskCrullerFinetuneCORDCfg
+from .task_cruller_finetune_xent import TaskCrullerFinetuneXent, TaskCrullerFinetuneXentCfg
+from .task_cruller_finetune_docvqa import TaskCrullerFinetuneDOCVQA, TaskCrullerFinetuneDOCVQACfg
+from .task_cruller_eval_ocr import TaskCrullerEvalOCR, TaskCrullerEvalOCRCfg
+from .task_donut_eval_ocr import TaskDonutEvalOCR, TaskDonutEvalOCRCfg
+from .task_cruller_eval_rvlcdip import TaskCrullerEvalRVLCDIP, TaskCrullerEvalRVLCDIPCfg
+from .task_cruller_eval_cord import TaskCrullerEvalCORD, TaskCrullerEvalCORDCfg
+from .task_cruller_eval_docvqa import TaskCrullerEvalDOCVQA, TaskCrullerEvalDOCVQACfg
+from .task_factory import TaskFactory
+
+# File: pixparse-main/src/pixparse/task/task_cruller_eval_cord.py
+import logging
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+import PIL
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torchvision import transforms
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from pixparse.framework import DeviceEnv, Monitor, TaskEval, TaskEvalCfg
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerCfg, TokenizerHF
+from pixparse.utils.json_utils import json2token, token2json
+from pixparse.utils.json_utils import JSONParseEvaluator
+import numpy as np
+from ast import literal_eval
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class TaskCrullerEvalCORDCfg(TaskEvalCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerEvalCORD(TaskEval):
+
+    def __init__(self, cfg: TaskCrullerEvalCORDCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_cord>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        cord_finetune_tokens = ['<sep/>', '<s_cord>', '</s_service_price>', '<s_subtotal_price>', '<s_discountprice>', '</s_sub>', '<s_sub>', '</s_total_etc>', '</s_discountprice>', '</s_vatyn>', '</s_subtotal_price>', '<s_changeprice>', '</s_total>', '</s_unitprice>', '<s_emoneyprice>', '</s_tax_price>', '</s_othersvc_price>', '</s_cnt>', '<s_vatyn>', '<s_unitprice>', '<s_total>', '<s_price>', '</s_price>', '<s_sub_total>', '</s_num>', '<s_total_etc>', '</s_creditcardprice>', '<s_tax_price>', '<s_menu>', '<s_nm>', '<s_menutype_cnt>', '</s_changeprice>', '<s_num>', '<s_itemsubtotal>', '</s_etc>', '<s_creditcardprice>', '</s_menuqty_cnt>', '</s_emoneyprice>', '<s_menuqty_cnt>', '<s_discount_price>', '</s_menu>', '</s_sub_total>', '<s_etc>', '</s_void_menu>', '<s_cashprice>', '</s_discount_price>', '</s_total_price>', '</s_nm>', '<s_service_price>', '<s_othersvc_price>', '</s_itemsubtotal>', '<s_void_menu>', '<s_total_price>', '</s_cashprice>', '</s_menutype_cnt>', '<s_cnt>']
+        special_tokens_from_pretrain = ['<sep/>', '<s_pretrain>']
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_eval = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        newly_added_num_from_pretrain = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens_from_pretrain))})
+        if newly_added_num_from_pretrain > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(cord_finetune_tokens))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        if newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_eval = transforms.Compose([transforms.ToTensor(), transforms.Grayscale(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+
+    def setup(self):
+        device = self.device_env.device
+        self.model.load_state_dict(self.resume_state_dict)
+        self.model.eval()
+        self.model.to(device)
+        self.all_ground_truths = []
+        self.all_predictions = []
+        self.acc_list = []
+        self.evaluator = JSONParseEvaluator()
+
+    def prepare_inputs_for_inference(self, input_ids: torch.Tensor, encoder_outputs: torch.Tensor, past_key_values=None, past=None, use_cache: bool=None, attention_mask: torch.Tensor=None):
+        if past is not None:
+            past_key_values = past
+        attention_mask = input_ids.ne(self.tokenizer.trunk.pad_token_id).long()
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+        output = {'input_ids': input_ids, 'attention_mask': attention_mask, 'past_key_values': past_key_values, 'use_cache': use_cache, 'encoder_hidden_states': encoder_outputs}
+        return output
+
+    def prepare_for_evaluation(self, loaders):
+        loaders = {loader_key: loader for (loader_key, loader) in loaders.items() if loader_key in ['eval', 'eval_FUNSD']}
+        return loaders
+
+    def safe_image_transform(self, img):
+        try:
+            transformed_img = self.image_preprocess_eval(img)
+        except PIL.UnidentifiedImageError as e:
+            print(f'Encountered PIL issue {e}. Filtering...')
+            transformed_img = None
+        return transformed_img
+
+    def text_input_to_target(self, text_input, ignore_id=-100):
+        target = text_input.clone()
+        target[target == self.tokenizer.trunk.pad_token_id] = ignore_id
+        prompt_end_token_id = self.tokenizer.trunk.convert_tokens_to_ids(self.prompt_end_token)
+        slice_id = torch.nonzero(target == prompt_end_token_id).sum() + 1
+        target[:slice_id] = ignore_id
+        return target
+
+    def collate_fn(self, batch):
+        tokenizer_fn = lambda x: self.tokenizer.trunk(x, add_special_tokens=False, return_tensors='pt', max_length=512, padding='max_length', truncation=True).input_ids[0]
+        images = [item['image'] for item in batch]
+        raw_texts = [literal_eval(item['ground_truth'])['gt_parse'] for item in batch]
+        inputs_to_stack = []
+        for text in raw_texts:
+            (tokens_from_json, _) = json2token(text, self.tokenizer.trunk.all_special_tokens, sort_json_key=False)
+            inputs_to_stack.append(tokenizer_fn(self.task_start_token + tokens_from_json + self.tokenizer.trunk.eos_token))
+        text_inputs = torch.stack(inputs_to_stack)
+        targets = torch.stack([self.text_input_to_target(text) for text in text_inputs])
+        transform = self.image_preprocess_eval
+        images = torch.stack([transform(img) for img in images])
+        text_inputs = text_inputs[:, :-1]
+        targets = targets[:, 1:]
+        return {'image': images, 'label': text_inputs, 'text_target': targets}
+
+    def step(self, batch):
+        metrics = {}
+        for (image, label) in zip(batch['image'], batch['label']):
+            decoded_gt = self.tokenizer.trunk.decode(label)
+            ground_truth = token2json(decoded_gt)
+            with torch.inference_mode():
+                tensor_image = image.unsqueeze(0).to(self.device_env.device)
+                output = self.model.image_encoder(tensor_image)
+                current_string = '<s_cord>'
+                input_ids = torch.tensor(self.tokenizer.trunk.encode('<s_cord>', add_special_tokens=False)).unsqueeze(0).to(self.device_env.device)
+                max_steps = 512
+                for step in range(max_steps):
+                    inputs = self.prepare_inputs_for_inference(input_ids=input_ids, encoder_outputs=output)
+                    decoder_outputs = self.model.text_decoder(**inputs)
+                    probabilities = F.softmax(decoder_outputs['logits'], dim=-1)
+                    next_token_id = torch.argmax(probabilities[0, -1]).item()
+                    next_token = self.tokenizer.trunk.decode([next_token_id])
+                    current_string += next_token
+                    if next_token == '</s>':
+                        break
+                    input_ids = torch.tensor(self.tokenizer.trunk.encode(current_string, add_special_tokens=False)).unsqueeze(0).to(self.device_env.device)
+                predicted_json = token2json(current_string)
+            self.all_predictions.append(predicted_json)
+            self.all_ground_truths.append(ground_truth)
+            acc = self.evaluator.cal_acc(predicted_json, ground_truth)
+            self.acc_list.append(acc)
+        metrics['batch_accuracy'] = acc
+        return metrics
+
+    def average_metrics(self, metrics: dict):
+        avg_accuracy = np.mean(self.acc_list)
+        f1 = self.evaluator.cal_f1(self.all_predictions, self.all_ground_truths)
+        self.all_ground_truths = []
+        self.all_predictions = []
+        self.acc_list = []
+        return {'average_accuracy': avg_accuracy, 'f1_score': f1}
+
+    def end(self):
+        pass
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_cruller_eval_docvqa.py
+import logging
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+import PIL
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torchvision import transforms
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from pixparse.framework import DeviceEnv, Monitor, TaskEval, TaskEvalCfg
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerCfg, TokenizerHF
+from pixparse.utils.json_utils import json2token, token2json
+from pixparse.utils.json_utils import JSONParseEvaluator
+from pixparse.utils.metrics import average_normalized_levenshtein_similarity
+import numpy as np
+from ast import literal_eval
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class TaskCrullerEvalDOCVQACfg(TaskEvalCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerEvalDOCVQA(TaskEval):
+
+    def __init__(self, cfg: TaskCrullerEvalDOCVQACfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_docvqa>'
+        self.prompt_end_token = '<s_answer>'
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        docvqa_finetune_tokens = ['<sep/>', self.task_start_token, self.prompt_end_token, '<s_question>', '</s_question>', '</s_answer>']
+        special_tokens_from_pretrain = ['<sep/>', '<s_pretrain>']
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_eval = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        newly_added_num_from_pretrain = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens_from_pretrain))})
+        if newly_added_num_from_pretrain > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(docvqa_finetune_tokens))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        if newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_eval = transforms.Compose([transforms.ToTensor(), transforms.Grayscale(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+        self.raw_predictions_test = dict()
+
+    def setup(self):
+        device = self.device_env.device
+        self.model.load_state_dict(self.resume_state_dict)
+        self.model.eval()
+        self.model.to(device)
+        self.all_ground_truths = []
+        self.all_predictions = []
+        self.acc_list = []
+        self.evaluator = JSONParseEvaluator()
+
+    def prepare_inputs_for_inference(self, input_ids: torch.Tensor, encoder_outputs: torch.Tensor, past_key_values=None, past=None, use_cache: bool=None, attention_mask: torch.Tensor=None):
+        if past is not None:
+            past_key_values = past
+        attention_mask = input_ids.ne(self.tokenizer.trunk.pad_token_id).long()
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+        output = {'input_ids': input_ids, 'attention_mask': attention_mask, 'past_key_values': past_key_values, 'use_cache': use_cache, 'encoder_hidden_states': encoder_outputs}
+        return output
+
+    def prepare_for_evaluation(self, loaders):
+        loaders = {loader_key: loader for (loader_key, loader) in loaders.items() if loader_key in ['eval', 'eval_FUNSD']}
+        return loaders
+
+    def safe_image_transform(self, img):
+        try:
+            transformed_img = self.image_preprocess_eval(img)
+        except PIL.UnidentifiedImageError as e:
+            print(f'Encountered PIL issue {e}. Filtering...')
+            transformed_img = None
+        return transformed_img
+
+    def text_input_to_target(self, text_input, ignore_id=-100):
+        target = text_input.clone()
+        target[target == self.tokenizer.trunk.pad_token_id] = ignore_id
+        prompt_end_token_id = self.tokenizer.trunk.convert_tokens_to_ids(self.prompt_end_token)
+        slice_id = torch.nonzero(target == prompt_end_token_id).sum() + 1
+        target[:slice_id] = ignore_id
+        return target
+
+    def collate_fn(self, batch):
+        question_ids = []
+        image_ids = []
+        images = []
+        questions = []
+        answers = []
+        for item in batch:
+            question_ids.append(item['question_id'])
+            image_ids.append(item['image_id'])
+            images.append(item['image'])
+            questions.append(item['labels']['question'])
+            answers.append(item['labels']['answers'])
+        transform = self.image_preprocess_eval
+        images = torch.stack([transform(img) for img in images])
+        return {'images': images, 'questions': questions, 'ground_truth_answers': answers, 'image_ids': image_ids, 'question_ids': question_ids}
+
+    def step(self, batch):
+        metrics = {}
+        image_outputs = self.model.image_encoder(batch['images'].to(self.device_env.device))
+        for (output, question, answers, question_id) in zip(image_outputs, batch['questions'], batch['ground_truth_answers'], batch['question_ids']):
+            self.all_ground_truths.append(answers)
+            with torch.inference_mode():
+                current_string = self.task_start_token + '<s_question>' + question + '</s_question>' + '<s_answer>'
+                input_ids = torch.tensor(self.tokenizer.trunk.encode(current_string, add_special_tokens=False)).unsqueeze(0).to(self.device_env.device)
+                max_steps = 512
+                for step in range(max_steps):
+                    inputs = self.prepare_inputs_for_inference(input_ids=input_ids, encoder_outputs=output)
+                    decoder_outputs = self.model.text_decoder(**inputs)
+                    probabilities = F.softmax(decoder_outputs['logits'], dim=-1)
+                    next_token_id = torch.argmax(probabilities[0, -1]).item()
+                    next_token = self.tokenizer.trunk.decode([next_token_id])
+                    current_string += next_token
+                    if next_token == '</s>':
+                        break
+                    input_ids = torch.tensor(self.tokenizer.trunk.encode(current_string, add_special_tokens=False)).unsqueeze(0).to(self.device_env.device)
+                predicted_json = token2json(current_string)
+            if 'answer' in predicted_json:
+                self.all_predictions.append(predicted_json['answer'])
+            else:
+                self.all_predictions.append('')
+        return metrics
+
+    def average_metrics(self, metrics: dict):
+        anls = average_normalized_levenshtein_similarity(ground_truth=self.all_ground_truths, predicted_answers=self.all_predictions)
+        return {'ANLS': anls}
+
+    def end(self):
+        pass
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_cruller_eval_ocr.py
+import logging
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+import torch
+import torchvision.transforms as transforms
+from pixparse.framework import TaskEvalCfg, TaskEval, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_text_anno
+from pixparse.utils import get_ocr_metrics
+from chug.common import LoaderBundle
+_logger = logging.getLogger(__name__)
+import time
+
+@dataclass
+class TaskCrullerEvalOCRCfg(TaskEvalCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerEvalOCR(TaskEval):
+
+    def __init__(self, cfg: TaskCrullerEvalOCRCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_pretrain>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        special_tokens = ['<sep/>', self.task_start_token, self.prompt_end_token]
+        newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        preproc_fn = preprocess_text_anno
+        self.anno_preprocess_eval = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        if newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_eval = transforms.Compose([transforms.ToTensor(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+        self.eval_metrics = {}
+        self.max_recursion_length = 1000
+
+    def time_and_log(func):
+
+        def wrapper(self, *args, **kwargs):
+            start_time = time.time()
+            result = func(self, *args, **kwargs)
+            end_time = time.time()
+            execution_time = end_time - start_time
+            _logger.info(f'Executed method {func.__name__} in {execution_time:.2f} seconds')
+            return result
+        return wrapper
+
+    def setup(self):
+        device = self.device_env.device
+        self.model.load_state_dict(self.resume_state_dict)
+        self.model.eval()
+        self.model.to(device)
+
+    def prepare_for_evaluation(self, loaders: dict[str, LoaderBundle]) -> dict[str, LoaderBundle]:
+        loaders = {loader_key: loader for (loader_key, loader) in loaders.items() if loader_key in ['eval', 'eval_FUNSD']}
+        return loaders
+
+    @time_and_log
+    def step(self, sample):
+        metrics = {}
+        (image_input, text_input, text_target) = sample
+        text_input = [item[0] for item in text_input]
+        text_input = torch.stack(text_input, dim=0).to(self.device_env.device, non_blocking=True)
+        text_target = [item[0] for item in text_target]
+        text_target = torch.stack(text_target, dim=0).to(self.device_env.device, non_blocking=True)
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        (ocr_metrics, _) = get_ocr_metrics(model=self.model, tokenizer=self.tokenizer, image_input=image_input, text_input=text_target, device_env=self.device_env, max_recursion_length=self.max_recursion_length, prompt_token=self.task_start_token)
+        metrics['ocr_reconstruction'] = ocr_metrics
+        return metrics
+
+    def average_metrics(self, metrics: dict):
+        wer_sum = 0
+        cer_sum = 0
+        for batch_metrics in metrics.values():
+            wer_sum += batch_metrics['ocr_reconstruction']['wer']
+            cer_sum += batch_metrics['ocr_reconstruction']['cer']
+        num_batches = len(metrics)
+        average_wer = wer_sum / num_batches
+        average_cer = cer_sum / num_batches
+        return {'ocr_reconstruction': {'wer': average_wer, 'cer': average_cer}}
+
+    def end(self):
+        pass
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_cruller_eval_rvlcdip.py
+import logging
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+import PIL
+import torch
+import torch.nn.functional as F
+from torchvision import transforms
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from pixparse.framework import DeviceEnv, Monitor, TaskEval, TaskEvalCfg
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerCfg, TokenizerHF
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class TaskCrullerEvalRVLCDIPCfg(TaskEvalCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerEvalRVLCDIP(TaskEval):
+
+    def __init__(self, cfg: TaskCrullerEvalRVLCDIPCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_rvlcdip>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        special_tokens = ['<sep/>', self.task_start_token, self.prompt_end_token, '<s_class>', '</s_class>', '<advertisement/>', '<budget/>', '<email/>', '<file_folder/>', '<form/>', '<handwritten/>', '<invoice/>', '<letter/>', '<memo/>', '<news_article/>', '<presentation/>', '<questionnaire/>', '<resume/>', '<scientific_publication/>', '<scientific_report/>', '<specification/>']
+        newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens))})
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        self.int2str = {0: 'letter', 1: 'form', 2: 'email', 3: 'handwritten', 4: 'advertisement', 5: 'scientific_report', 6: 'scientific_publication', 7: 'specification', 8: 'file_folder', 9: 'news_article', 10: 'budget', 11: 'invoice', 12: 'presentation', 13: 'questionnaire', 14: 'resume', 15: 'memo'}
+        self.vocab_size = len(self.tokenizer.trunk)
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_eval = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        if newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_eval = transforms.Compose([transforms.ToTensor(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+
+    def setup(self):
+        device = self.device_env.device
+        self.model.load_state_dict(self.resume_state_dict)
+        self.model.eval()
+        self.model.to(device)
+
+    def prepare_inputs_for_inference(self, input_ids: torch.Tensor, encoder_outputs: torch.Tensor, past_key_values=None, past=None, use_cache: bool=None, attention_mask: torch.Tensor=None):
+        if past is not None:
+            past_key_values = past
+        attention_mask = input_ids.ne(self.tokenizer.trunk.pad_token_id).long()
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+        output = {'input_ids': input_ids, 'attention_mask': attention_mask, 'past_key_values': past_key_values, 'use_cache': use_cache, 'encoder_hidden_states': encoder_outputs}
+        return output
+
+    def prepare_for_evaluation(self, loaders):
+        loaders = {loader_key: loader for (loader_key, loader) in loaders.items() if loader_key in ['eval', 'eval_FUNSD']}
+        return loaders
+
+    def safe_image_transform(self, img):
+        try:
+            transformed_img = self.image_preprocess_eval(img)
+        except PIL.UnidentifiedImageError as e:
+            print(f'Encountered PIL issue {e}. Filtering...')
+            transformed_img = None
+        return transformed_img
+
+    def collate_fn(self, batch):
+        images = [item['image'] for item in batch if item is not None]
+        labels = [item['label'] for item in batch if item is not None]
+        if len(images) == 0:
+            return None
+        transformed_images = [self.safe_image_transform(img) for img in images]
+        valid_indices = [i for (i, img) in enumerate(transformed_images) if img is not None]
+        images = torch.stack([transformed_images[i] for i in valid_indices])
+        labels = torch.tensor([labels[i] for i in valid_indices], dtype=torch.int64)
+        return {'image': images, 'label': labels}
+
+    def step(self, sample):
+        metrics = {}
+        metrics['classification'] = dict()
+        correct_samples = 0
+        ground_truths = [self.int2str[int(gt)] for gt in sample['label']]
+        already_counted = [False] * len(ground_truths)
+        with torch.inference_mode():
+            tensor_images = torch.stack([im for im in sample['image']]).to(self.device_env.device)
+            output = self.model.image_encoder(tensor_images)
+            current_strings = ['<s_rvlcdip>' for _ in range(tensor_images.shape[0])]
+            input_ids = torch.tensor(self.tokenizer.trunk.encode('<s_rvlcdip>')[1]).unsqueeze(0).repeat(tensor_images.shape[0], 1).to(self.device_env.device)
+            max_steps = 5
+            for step in range(max_steps):
+                inputs = self.prepare_inputs_for_inference(input_ids=input_ids, encoder_outputs=output)
+                decoder_outputs = self.model.text_decoder(**inputs)
+                probabilities = F.softmax(decoder_outputs['logits'], dim=-1)
+                next_token_ids = torch.argmax(probabilities, dim=-1)
+                for idx in range(next_token_ids.shape[0]):
+                    next_token_id = next_token_ids[idx, -1].item()
+                    next_token = self.tokenizer.trunk.decode([next_token_id])
+                    current_strings[idx] += next_token
+                    if next_token == '</s>':
+                        generated_label = current_strings[idx].replace('<s_rvlcdip>', '').replace('</s>', '').replace('<s>', '').strip()
+                        ground_truth_label = '<' + ground_truths[idx] + '/>'
+                        if generated_label == ground_truth_label and (not already_counted[idx]):
+                            correct_samples += 1
+                            already_counted[idx] = True
+                input_ids = torch.tensor([self.tokenizer.trunk.encode(s)[1:] for s in current_strings]).to(self.device_env.device)
+        metrics['classification']['correct_samples'] = correct_samples
+        metrics['classification']['n_valid_samples'] = len(sample['label'])
+        return metrics
+
+    def average_metrics(self, metrics: dict):
+        correct_samples = 0
+        total_samples = 0
+        for batch_metrics in metrics.values():
+            correct_samples += batch_metrics['classification']['correct_samples']
+            total_samples += batch_metrics['classification']['n_valid_samples']
+        average_acc = correct_samples / total_samples
+        return {'classification': {'accuracy': average_acc}}
+
+    def end(self):
+        pass
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_cruller_finetune_CORD.py
+import logging
+from contextlib import nullcontext
+from dataclasses import dataclass, field, asdict
+from functools import partial
+from typing import Optional, List, Any
+import torch
+from torch.utils.data import DataLoader
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+from torchvision.transforms import functional as transformsF
+from torchvision.transforms import Lambda
+import timm
+import timm.utils
+from timm.optim import create_optimizer_v2
+from timm.scheduler import create_scheduler_v2
+from pixparse.framework import TaskTrainCfg, TaskTrain, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from timm.layers import SelectAdaptivePool2d
+from typing import Dict, List
+from collections import OrderedDict
+from ast import literal_eval
+from datasets import load_dataset
+from pixparse.utils.json_utils import json2token, token2json
+from transformers import DonutProcessor, VisionEncoderDecoderModel
+from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from pixparse.utils.json_utils import JSONParseEvaluator
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class TaskCrullerFinetuneCORDCfg(TaskTrainCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+def prepare_inputs_for_inference(tokenizer, input_ids: torch.Tensor, encoder_outputs: torch.Tensor, past_key_values=None, past=None, use_cache: bool=None, attention_mask: torch.Tensor=None):
+    if past is not None:
+        past_key_values = past
+    attention_mask = input_ids.ne(tokenizer.trunk.pad_token_id).long()
+    if past_key_values is not None:
+        input_ids = input_ids[:, -1:]
+    output = {'input_ids': input_ids, 'attention_mask': attention_mask, 'past_key_values': past_key_values, 'use_cache': use_cache, 'encoder_hidden_states': encoder_outputs}
+    return output
+
+class TaskCrullerFinetuneCORD(TaskTrain):
+
+    def __init__(self, cfg: TaskCrullerFinetuneCORDCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_cord>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        self.special_tokens_finetune = ['<sep/>', self.task_start_token, self.prompt_end_token, '</s_service_price>', '<s_subtotal_price>', '<s_discountprice>', '</s_sub>', '<s_sub>', '</s_total_etc>', '</s_discountprice>', '</s_vatyn>', '</s_subtotal_price>', '<s_changeprice>', '</s_total>', '</s_unitprice>', '<s_emoneyprice>', '</s_tax_price>', '</s_othersvc_price>', '</s_cnt>', '<s_vatyn>', '<s_unitprice>', '<s_total>', '<s_price>', '</s_price>', '<s_sub_total>', '</s_num>', '<s_total_etc>', '</s_creditcardprice>', '<s_tax_price>', '<s_menu>', '<s_nm>', '<s_menutype_cnt>', '</s_changeprice>', '<s_num>', '<s_itemsubtotal>', '</s_etc>', '<s_creditcardprice>', '</s_menuqty_cnt>', '</s_emoneyprice>', '<s_menuqty_cnt>', '<s_discount_price>', '</s_menu>', '</s_sub_total>', '<s_etc>', '</s_void_menu>', '<s_cashprice>', '</s_discount_price>', '</s_total_price>', '</s_nm>', '<s_service_price>', '<s_othersvc_price>', '</s_itemsubtotal>', '<s_void_menu>', '<s_total_price>', '</s_cashprice>', '</s_menutype_cnt>', '<s_cnt>']
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_train = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        ''
+        self.finetune_donut_weights = False
+        _logger.info(f'Finetuning donut weights? {self.finetune_donut_weights}')
+        if self.finetune_donut_weights:
+            self.model = VisionEncoderDecoderModel.from_pretrained('naver-clova-ix/donut-base')
+        else:
+            self.model = Cruller(cfg.model)
+            special_tokens_from_pretrain = ['<sep/>', '<s_pretrain>']
+            num_tokens_from_pretrain = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens_from_pretrain))})
+            if num_tokens_from_pretrain > 0:
+                self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        if self.finetune_donut_weights:
+            self.num_image_chs = 3
+        else:
+            self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        if self.finetune_donut_weights:
+            img_mean = IMAGENET_DEFAULT_MEAN
+            img_std = IMAGENET_DEFAULT_STD
+        else:
+            img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+            img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        if self.finetune_donut_weights:
+            image_size = (1280, 960)
+            color_transform = Lambda(lambda x: x)
+        else:
+            image_size = cfg.model.image_encoder.image_size
+            color_transform = transforms.Grayscale()
+        self.image_preprocess_train = transforms.Compose([transforms.ToTensor(), color_transform, transforms.Resize(image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+
+    def train_setup(self, num_batches_per_interval: int):
+        if self.finetune_donut_weights:
+            self.newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(self.special_tokens_finetune))})
+            self.vocab_size = len(self.tokenizer.trunk)
+            if self.newly_added_num > 0:
+                self.model.decoder.resize_token_embeddings(len(self.tokenizer.trunk))
+        else:
+            _logger.info(f'Resuming from existing checkpoint. ')
+            self.state_dict = {k.replace('module.', ''): v for (k, v) in self.state_dict.items()}
+            self.model.load_state_dict(self.state_dict)
+            self.newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(self.special_tokens_finetune))})
+            self.vocab_size = len(self.tokenizer.trunk)
+            if self.newly_added_num > 0:
+                self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        device = self.device_env.device
+        self.model.to(device)
+        if self.device_env.world_size > 1:
+            self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[device], static_graph=True)
+            self.has_no_sync = hasattr(self.model, 'no_sync')
+        opt_kwargs = {}
+        if self.cfg.opt.betas is not None:
+            opt_kwargs['betas'] = self.cfg.opt.betas
+        if self.cfg.opt.momentum is not None:
+            opt_kwargs['momentum'] = self.cfg.opt.momentum
+        self.optimizer = create_optimizer_v2(self.model, self.cfg.opt.optimizer, lr=self.cfg.opt.learning_rate, eps=self.cfg.opt.eps, layer_decay=self.cfg.opt.layer_decay, **opt_kwargs)
+        if self.cfg.amp:
+            self.scaler = timm.utils.NativeScaler()
+            self.autocast = partial(torch.autocast, device_type=device.type, dtype=self.amp_dtype)
+        else:
+            self.scaler = None
+            self.autocast = nullcontext
+        self.num_steps_per_interval = num_batches_per_interval // self.cfg.opt.grad_accum_steps
+        (self.scheduler, num_scheduled_epochs) = create_scheduler_v2(self.optimizer, self.cfg.opt.scheduler, warmup_lr=self.cfg.opt.warmup_learning_rate, warmup_epochs=self.num_warmup_intervals, num_epochs=self.num_intervals, step_on_epochs=False, updates_per_epoch=self.num_steps_per_interval)
+        self.scheduler.step_update(0)
+
+    def text_input_to_target(self, text_input, ignore_id=-100):
+        target = text_input.clone()
+        target[target == self.tokenizer.trunk.pad_token_id] = ignore_id
+        prompt_end_token_id = self.tokenizer.trunk.convert_tokens_to_ids(self.prompt_end_token)
+        slice_id = torch.nonzero(target == prompt_end_token_id).sum() + 1
+        target[:slice_id] = ignore_id
+        return target
+
+    def collate_fn(self, batch):
+        tokenizer_fn = lambda x: self.tokenizer.trunk(x, add_special_tokens=False, return_tensors='pt', max_length=512, padding='max_length', truncation=True).input_ids[0]
+        images = [item['image'] for item in batch]
+        raw_texts = [literal_eval(item['ground_truth'])['gt_parse'] for item in batch]
+        inputs_to_stack = []
+        for text in raw_texts:
+            (tokens_from_json, _) = json2token(text, self.tokenizer.trunk.all_special_tokens, sort_json_key=False)
+            inputs_to_stack.append(tokenizer_fn(self.task_start_token + tokens_from_json + self.tokenizer.trunk.eos_token))
+        text_inputs = torch.stack(inputs_to_stack)
+        targets = torch.stack([self.text_input_to_target(text) for text in text_inputs])
+        transform = self.image_preprocess_train
+        images = torch.stack([transform(img) for img in images])
+        text_inputs = text_inputs[:, :-1]
+        targets = targets[:, 1:]
+        return {'image': images, 'label': text_inputs, 'text_target': targets}
+
+    def train_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        image_input = sample['image']
+        label = sample['label']
+        text_target = sample['text_target']
+        result = {}
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        label = label.to(self.device_env.device, non_blocking=True)
+        text_target = text_target.to(self.device_env.device, non_blocking=True)
+        accum_steps = self.cfg.opt.grad_accum_steps
+        need_update = (self.interval_batch_idx + 1) % accum_steps == 0
+
+        def _forward():
+            with self.autocast():
+                if self.finetune_donut_weights:
+                    output = self.model(pixel_values=image_input, decoder_input_ids=label, labels=text_target)
+                    logits = output['logits']
+                else:
+                    output = self.model(image_input, label)
+                    logits = output['logits']
+                loss = self.loss(logits.view(-1, self.vocab_size), text_target.view(-1))
+            if accum_steps > 1:
+                loss /= accum_steps
+            return loss
+
+        def _backward(_loss):
+            if self.scaler is not None:
+                self.scaler(_loss, self.optimizer, clip_grad=self.cfg.opt.clip_grad_value, clip_mode=self.cfg.opt.clip_grad_mode, parameters=self.model.parameters(), need_update=need_update)
+            else:
+                _loss.backward()
+                if need_update:
+                    if self.cfg.opt.clip_grad_value is not None:
+                        timm.utils.dispatch_clip_grad(self.model.parameters(), value=self.cfg.opt.clip_grad_value, mode=self.cfg.opt.clip_grad_mode)
+                    self.optimizer.step()
+        if self.has_no_sync and (not need_update):
+            with self.model.no_sync():
+                loss = _forward()
+                _backward(loss)
+        else:
+            loss = _forward()
+            _backward(loss)
+        self.batch_idx += 1
+        self.interval_batch_idx += 1
+        if self.step % 100 == 0:
+            self.monitor.log_step('finetune', step_idx=self.step, step_end_idx=self.num_intervals * self.num_steps_per_interval, interval=self.interval_idx, loss=loss.item(), lr=self.get_current_lr(), metrics=None, eval_data=None)
+        if not need_update:
+            return result
+        self.step += 1
+        self.scheduler.step_update(self.step)
+        self.optimizer.zero_grad()
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        state_dicts['tokenizer'] = self.tokenizer.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_cruller_finetune_RVLCDIP.py
+import logging
+from contextlib import nullcontext
+from dataclasses import dataclass, field, asdict
+from functools import partial
+from typing import Optional, List, Any
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+import timm
+import timm.utils
+from timm.optim import create_optimizer_v2
+from timm.scheduler import create_scheduler_v2
+from pixparse.framework import TaskTrainCfg, TaskTrain, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from timm.layers import SelectAdaptivePool2d
+from typing import Dict, List
+from collections import OrderedDict
+_logger = logging.getLogger(__name__)
+
+class GetCLSToken(nn.Module):
+
+    def forward(self, x):
+        return x[:, 0, :]
+
+@dataclass
+class TaskCrullerFinetuneRVLCDIPCfg(TaskTrainCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerFinetuneRVLCDIP(TaskTrain):
+
+    def __init__(self, cfg: TaskCrullerFinetuneRVLCDIPCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_rvlcdip>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        self.special_tokens_finetune = ['<sep/>', self.task_start_token, self.prompt_end_token, '<s_class>', '</s_class>', '<advertisement/>', '<budget/>', '<email/>', '<file_folder/>', '<form/>', '<handwritten/>', '<invoice/>', '<letter/>', '<memo/>', '<news_article/>', '<presentation/>', '<questionnaire/>', '<resume/>', '<scientific_publication/>', '<scientific_report/>', '<specification/>']
+        self.int2str = {0: 'letter', 1: 'form', 2: 'email', 3: 'handwritten', 4: 'advertisement', 5: 'scientific_report', 6: 'scientific_publication', 7: 'specification', 8: 'file_folder', 9: 'news_article', 10: 'budget', 11: 'invoice', 12: 'presentation', 13: 'questionnaire', 14: 'resume', 15: 'memo'}
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_train = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        special_tokens_from_pretrain = ['<sep/>', '<s_pretrain>']
+        num_tokens_from_pretrain = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens_from_pretrain))})
+        if num_tokens_from_pretrain > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_train = transforms.Compose([transforms.ToTensor(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+
+    def train_setup(self, num_batches_per_interval: int):
+        _logger.info(f'Resuming from existing checkpoint. ')
+        self.state_dict = {k.replace('module.', ''): v for (k, v) in self.state_dict.items()}
+        self.model.load_state_dict(self.state_dict)
+        self.newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(self.special_tokens_finetune))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        if self.newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        device = self.device_env.device
+        self.model.to(device)
+        if self.device_env.world_size > 1:
+            self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[device], static_graph=True)
+            self.has_no_sync = hasattr(self.model, 'no_sync')
+        opt_kwargs = {}
+        if self.cfg.opt.betas is not None:
+            opt_kwargs['betas'] = self.cfg.opt.betas
+        if self.cfg.opt.momentum is not None:
+            opt_kwargs['momentum'] = self.cfg.opt.momentum
+        self.optimizer = create_optimizer_v2(self.model, self.cfg.opt.optimizer, lr=self.cfg.opt.learning_rate, eps=self.cfg.opt.eps, layer_decay=self.cfg.opt.layer_decay, **opt_kwargs)
+        if self.cfg.amp:
+            self.scaler = timm.utils.NativeScaler()
+            self.autocast = partial(torch.autocast, device_type=device.type, dtype=self.amp_dtype)
+        else:
+            self.scaler = None
+            self.autocast = nullcontext
+        self.num_steps_per_interval = num_batches_per_interval // self.cfg.opt.grad_accum_steps
+        (self.scheduler, num_scheduled_epochs) = create_scheduler_v2(self.optimizer, self.cfg.opt.scheduler, warmup_lr=self.cfg.opt.warmup_learning_rate, warmup_epochs=self.num_warmup_intervals, num_epochs=self.num_intervals, step_on_epochs=False, updates_per_epoch=self.num_steps_per_interval)
+        self.scheduler.step_update(0)
+
+    def text_input_to_target(self, text_input, ignore_id=-100):
+        target = text_input.clone()
+        target[target == self.tokenizer.trunk.pad_token_id] = ignore_id
+        prompt_end_token_id = self.tokenizer.trunk.convert_tokens_to_ids(self.prompt_end_token)
+        target[:torch.nonzero(target == prompt_end_token_id).sum() + 1] = ignore_id
+        return target
+
+    def collate_fn(self, batch):
+        images = [item['image'] for item in batch]
+        labels = [item['label'] for item in batch]
+        tokenizer_fn = lambda x: self.tokenizer.trunk(x, add_special_tokens=False, return_tensors='pt', max_length=5, padding='max_length', truncation=True).input_ids[0]
+        labels_tokens = [tokenizer_fn(self.task_start_token + '<' + self.int2str[label] + '/>' + self.tokenizer.trunk.eos_token) for label in labels]
+        transform = self.image_preprocess_train
+        images = torch.stack([transform(img) for img in images])
+        labels = torch.stack(labels_tokens)
+        targets = torch.stack([self.text_input_to_target(text) for text in labels])
+        labels = labels[:, :-1]
+        targets = targets[:, 1:]
+        return {'image': images, 'label': labels, 'text_target': targets}
+
+    def train_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        image_input = sample['image']
+        label = sample['label']
+        text_target = sample['text_target']
+        result = {}
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        label = label.to(self.device_env.device, non_blocking=True)
+        text_target = text_target.to(self.device_env.device, non_blocking=True)
+        accum_steps = self.cfg.opt.grad_accum_steps
+        need_update = (self.interval_batch_idx + 1) % accum_steps == 0
+
+        def _forward():
+            with self.autocast():
+                output = self.model(image_input, label)
+                logits = output['logits']
+                loss = self.loss(logits.view(-1, self.vocab_size), text_target.view(-1))
+            if accum_steps > 1:
+                loss /= accum_steps
+            return loss
+
+        def _backward(_loss):
+            if self.scaler is not None:
+                self.scaler(_loss, self.optimizer, clip_grad=self.cfg.opt.clip_grad_value, clip_mode=self.cfg.opt.clip_grad_mode, parameters=self.model.parameters(), need_update=need_update)
+            else:
+                _loss.backward()
+                if need_update:
+                    if self.cfg.opt.clip_grad_value is not None:
+                        timm.utils.dispatch_clip_grad(self.model.parameters(), value=self.cfg.opt.clip_grad_value, mode=self.cfg.opt.clip_grad_mode)
+                    self.optimizer.step()
+        if self.has_no_sync and (not need_update):
+            with self.model.no_sync():
+                loss = _forward()
+                _backward(loss)
+        else:
+            loss = _forward()
+            _backward(loss)
+        self.batch_idx += 1
+        self.interval_batch_idx += 1
+        if self.step % self.eval_frequency == 0:
+            self.monitor.log_step('finetune', step_idx=self.step, step_end_idx=self.num_intervals * self.num_steps_per_interval, interval=self.interval_idx, loss=loss.item(), lr=self.get_current_lr(), metrics=None, eval_data=None)
+        if not need_update:
+            return result
+        self.step += 1
+        self.scheduler.step_update(self.step)
+        self.optimizer.zero_grad()
+
+# File: pixparse-main/src/pixparse/task/task_cruller_finetune_docvqa.py
+import logging
+from contextlib import nullcontext
+from dataclasses import dataclass, field, asdict
+from functools import partial
+from typing import Optional, List, Any
+import torch
+from torch.utils.data import DataLoader
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+from torchvision.transforms import functional as transformsF
+from torchvision.transforms import Lambda
+import timm
+import timm.utils
+from timm.optim import create_optimizer_v2
+from timm.scheduler import create_scheduler_v2
+from pixparse.framework import TaskTrainCfg, TaskTrain, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from timm.layers import SelectAdaptivePool2d
+from typing import Dict, List
+from collections import OrderedDict
+from ast import literal_eval
+from datasets import load_dataset
+from pixparse.utils.json_utils import json2token, token2json
+from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from pixparse.utils.json_utils import JSONParseEvaluator
+import numpy as np
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class TaskCrullerFinetuneDOCVQACfg(TaskTrainCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerFinetuneDOCVQA(TaskTrain):
+
+    def __init__(self, cfg: TaskCrullerFinetuneDOCVQACfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_docvqa>'
+        self.prompt_end_token = '<s_answer>'
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = True
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        self.special_tokens_finetune = ['<sep/>', self.task_start_token, self.prompt_end_token, '<s_question>', '</s_question>', '</s_answer>']
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_train = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        special_tokens_from_pretrain = ['<sep/>', '<s_pretrain>']
+        num_tokens_from_pretrain = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens_from_pretrain))})
+        if num_tokens_from_pretrain > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        image_size = cfg.model.image_encoder.image_size
+        color_transform = transforms.Grayscale()
+        self.image_preprocess_train = transforms.Compose([transforms.ToTensor(), color_transform, transforms.Resize(image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+
+    def train_setup(self, num_batches_per_interval: int):
+        _logger.info(f'Resuming from existing checkpoint. ')
+        self.state_dict = {k.replace('module.', ''): v for (k, v) in self.state_dict.items()}
+        self.model.load_state_dict(self.state_dict)
+        self.newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(self.special_tokens_finetune))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        if self.newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        device = self.device_env.device
+        self.model.to(device)
+        if self.device_env.world_size > 1:
+            self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[device], static_graph=True)
+            self.has_no_sync = hasattr(self.model, 'no_sync')
+        opt_kwargs = {}
+        if self.cfg.opt.betas is not None:
+            opt_kwargs['betas'] = self.cfg.opt.betas
+        if self.cfg.opt.momentum is not None:
+            opt_kwargs['momentum'] = self.cfg.opt.momentum
+        self.optimizer = create_optimizer_v2(self.model, self.cfg.opt.optimizer, lr=self.cfg.opt.learning_rate, eps=self.cfg.opt.eps, layer_decay=self.cfg.opt.layer_decay, **opt_kwargs)
+        if self.cfg.amp:
+            self.scaler = timm.utils.NativeScaler()
+            self.autocast = partial(torch.autocast, device_type=device.type, dtype=self.amp_dtype)
+        else:
+            self.scaler = None
+            self.autocast = nullcontext
+        self.num_steps_per_interval = num_batches_per_interval // self.cfg.opt.grad_accum_steps
+        (self.scheduler, num_scheduled_epochs) = create_scheduler_v2(self.optimizer, self.cfg.opt.scheduler, warmup_lr=self.cfg.opt.warmup_learning_rate, warmup_epochs=self.num_warmup_intervals, num_epochs=self.num_intervals, step_on_epochs=False, updates_per_epoch=self.num_steps_per_interval)
+        self.scheduler.step_update(0)
+
+    def text_input_to_target(self, text_input, ignore_id=-100):
+        target = text_input.clone()
+        target[target == self.tokenizer.trunk.pad_token_id] = ignore_id
+        prompt_end_token_id = self.tokenizer.trunk.convert_tokens_to_ids(self.prompt_end_token)
+        slice_id = torch.nonzero(target == prompt_end_token_id).sum() + 1
+        target[:slice_id] = ignore_id
+        return target
+
+    def collate_fn(self, batch):
+        tokenizer_fn = lambda x: self.tokenizer.trunk(x, add_special_tokens=False, return_tensors='pt', max_length=512, padding='max_length', truncation=True).input_ids[0]
+        images = [item['image'] for item in batch]
+        q_and_as = [np.random.choice(item['labels']) for item in batch]
+        inputs_to_stack = []
+        for text in q_and_as:
+            inputs_to_stack.append(tokenizer_fn('<s_docvqa>' + text + self.tokenizer.trunk.eos_token))
+        text_inputs = torch.stack(inputs_to_stack)
+        targets = torch.stack([self.text_input_to_target(text) for text in text_inputs])
+        transform = self.image_preprocess_train
+        images = torch.stack([transform(img) for img in images])
+        text_inputs = text_inputs[:, :-1]
+        targets = targets[:, 1:]
+        return {'image': images, 'label': text_inputs, 'text_target': targets}
+
+    def train_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        image_input = sample['image']
+        label = sample['label']
+        text_target = sample['text_target']
+        result = {}
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        label = label.to(self.device_env.device, non_blocking=True)
+        text_target = text_target.to(self.device_env.device, non_blocking=True)
+        accum_steps = self.cfg.opt.grad_accum_steps
+        need_update = (self.interval_batch_idx + 1) % accum_steps == 0
+
+        def _forward():
+            with self.autocast():
+                output = self.model(image_input, label)
+                logits = output['logits']
+                loss = self.loss(logits.view(-1, self.vocab_size), text_target.view(-1))
+            if accum_steps > 1:
+                loss /= accum_steps
+            return loss
+
+        def _backward(_loss):
+            if self.scaler is not None:
+                self.scaler(_loss, self.optimizer, clip_grad=self.cfg.opt.clip_grad_value, clip_mode=self.cfg.opt.clip_grad_mode, parameters=self.model.parameters(), need_update=need_update)
+            else:
+                _loss.backward()
+                if need_update:
+                    if self.cfg.opt.clip_grad_value is not None:
+                        timm.utils.dispatch_clip_grad(self.model.parameters(), value=self.cfg.opt.clip_grad_value, mode=self.cfg.opt.clip_grad_mode)
+                    self.optimizer.step()
+        if self.has_no_sync and (not need_update):
+            with self.model.no_sync():
+                loss = _forward()
+                _backward(loss)
+        else:
+            loss = _forward()
+            _backward(loss)
+        self.batch_idx += 1
+        self.interval_batch_idx += 1
+        if self.step % 100 == 0:
+            self.monitor.log_step('finetune', step_idx=self.step, step_end_idx=self.num_intervals * self.num_steps_per_interval, interval=self.interval_idx, loss=loss.item(), lr=self.get_current_lr(), metrics=None, eval_data=None)
+        if not need_update:
+            return result
+        self.step += 1
+        self.scheduler.step_update(self.step)
+        self.optimizer.zero_grad()
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        state_dicts['tokenizer'] = self.tokenizer.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_cruller_finetune_xent.py
+import logging
+from contextlib import nullcontext
+from dataclasses import dataclass, field, asdict
+from functools import partial
+from typing import Optional, List, Any
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+import timm
+import timm.utils
+from timm.optim import create_optimizer_v2
+from timm.scheduler import create_scheduler_v2
+from pixparse.framework import TaskTrainCfg, TaskTrain, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from timm.layers import SelectAdaptivePool2d
+from typing import Dict, List
+from collections import OrderedDict
+_logger = logging.getLogger(__name__)
+
+class GetCLSToken(nn.Module):
+
+    def forward(self, x):
+        return x[:, 0, :]
+
+@dataclass
+class TaskCrullerFinetuneXentCfg(TaskTrainCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerFinetuneXent(TaskTrain):
+
+    def __init__(self, cfg: TaskCrullerFinetuneXentCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_finetune>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = False
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        self.state_dict = OrderedDict()
+        self.resume = False
+        special_tokens = ['<sep/>', self.task_start_token, self.prompt_end_token]
+        newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_train = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        if newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_train = transforms.Compose([transforms.ToTensor(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+
+    def train_setup(self, num_batches_per_interval: int):
+        if self.resume:
+            _logger.info(f'Resuming from existing checkpoint. ')
+            self.state_dict = {k.replace('module.', ''): v for (k, v) in self.state_dict.items()}
+            self.model.load_state_dict(self.state_dict)
+        self.model = nn.Sequential(OrderedDict([('encoder', self.model.image_encoder), ('token_pool', GetCLSToken()), ('final_fc', nn.Linear(768, 16))]))
+        device = self.device_env.device
+        print(f'Local rank for this process: {self.device_env.local_rank}')
+        device = torch.device(f'cuda:{self.device_env.local_rank}')
+        self.model.to(device)
+        if self.device_env.world_size > 1:
+            self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[device], static_graph=True)
+            self.has_no_sync = hasattr(self.model, 'no_sync')
+        opt_kwargs = {}
+        if self.cfg.opt.betas is not None:
+            opt_kwargs['betas'] = self.cfg.opt.betas
+        if self.cfg.opt.momentum is not None:
+            opt_kwargs['momentum'] = self.cfg.opt.momentum
+        self.optimizer = create_optimizer_v2(self.model, self.cfg.opt.optimizer, lr=self.cfg.opt.learning_rate, eps=self.cfg.opt.eps, layer_decay=self.cfg.opt.layer_decay, **opt_kwargs)
+        if self.cfg.amp:
+            self.scaler = timm.utils.NativeScaler()
+            self.autocast = partial(torch.autocast, device_type=device.type, dtype=self.amp_dtype)
+        else:
+            self.scaler = None
+            self.autocast = nullcontext
+        self.num_steps_per_interval = num_batches_per_interval // self.cfg.opt.grad_accum_steps
+        (self.scheduler, num_scheduled_epochs) = create_scheduler_v2(self.optimizer, self.cfg.opt.scheduler, warmup_lr=self.cfg.opt.warmup_learning_rate, warmup_epochs=self.num_warmup_intervals, num_epochs=self.num_intervals, step_on_epochs=False, updates_per_epoch=self.num_steps_per_interval)
+        self.scheduler.step_update(0)
+
+    def collate_fn(self, batch):
+        images = [item['image'] for item in batch]
+        labels = [item['label'] for item in batch]
+        transform = self.image_preprocess_train
+        images = torch.stack([transform(img) for img in images])
+        labels = torch.tensor(labels, dtype=torch.int64)
+        return {'image': images, 'label': labels}
+
+    def train_interval_start(self):
+        self.optimizer.zero_grad()
+        self.interval_batch_idx = 0
+
+    def train_interval_end(self):
+        self.monitor.log_phase('finetune', self.interval_idx)
+        self.interval_idx += 1
+
+    def train_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        image_input = sample['image']
+        label = sample['label']
+        result = {}
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        label = label.to(self.device_env.device, non_blocking=True)
+        accum_steps = self.cfg.opt.grad_accum_steps
+        need_update = (self.interval_batch_idx + 1) % accum_steps == 0
+
+        def _forward():
+            with self.autocast():
+                outputs = self.model(image_input)
+                loss = self.loss(outputs, label)
+            if accum_steps > 1:
+                loss /= accum_steps
+            return loss
+
+        def _backward(_loss):
+            if self.scaler is not None:
+                self.scaler(_loss, self.optimizer, clip_grad=self.cfg.opt.clip_grad_value, clip_mode=self.cfg.opt.clip_grad_mode, parameters=self.model.parameters(), need_update=need_update)
+            else:
+                _loss.backward()
+                if need_update:
+                    if self.cfg.opt.clip_grad_value is not None:
+                        timm.utils.dispatch_clip_grad(self.model.parameters(), value=self.cfg.opt.clip_grad_value, mode=self.cfg.opt.clip_grad_mode)
+                    self.optimizer.step()
+        if self.has_no_sync and (not need_update):
+            with self.model.no_sync():
+                loss = _forward()
+                _backward(loss)
+        else:
+            loss = _forward()
+            _backward(loss)
+        self.batch_idx += 1
+        self.interval_batch_idx += 1
+        if self.step % self.eval_frequency == 0:
+            self.monitor.log_step('finetune', step_idx=self.step, step_end_idx=self.num_intervals * self.num_steps_per_interval, interval=self.interval_idx, loss=loss.item(), lr=self.get_current_lr(), metrics=None, eval_data=None)
+        if not need_update:
+            return result
+        self.step += 1
+        self.scheduler.step_update(self.step)
+        self.optimizer.zero_grad()
+
+    def eval_step(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        pass
+
+    def get_current_lr(self):
+        lrl = [param_group['lr'] for param_group in self.optimizer.param_groups]
+        lr = sum(lrl) / len(lrl)
+        return lr
+
+# File: pixparse-main/src/pixparse/task/task_cruller_pretrain.py
+import logging
+from contextlib import nullcontext
+from dataclasses import dataclass, field, asdict
+from functools import partial
+from typing import Optional, List, Any
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+import timm
+import timm.utils
+from timm.optim import create_optimizer_v2
+from timm.scheduler import create_scheduler_v2
+from pixparse.framework import TaskTrainCfg, TaskTrain, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_ocr_anno, preprocess_text_anno
+from pixparse.utils.ocr_utils import get_ocr_metrics
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class TaskCrullerPretrainCfg(TaskTrainCfg):
+    model_name: Optional[str] = None
+    model: ModelCfg = field(default_factory=ModelCfg)
+    tokenizer: TokenizerCfg = field(default_factory=TokenizerCfg)
+
+    def __post_init__(self):
+        if self.model_name:
+            model = get_model_config(self.model_name)
+            if model is None:
+                _logger.warning(f'Model config for {self.model_name} was not found, using defaults.')
+            else:
+                self.model = model
+        else:
+            self.model_name = 'custom'
+
+class TaskCrullerPretrain(TaskTrain):
+
+    def __init__(self, cfg: TaskCrullerPretrainCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.amp_dtype = None
+        if cfg.dtype is not None:
+            self.amp_dtype = torch.bfloat16 if cfg.dtype in ('bfloat16', 'bf16') else torch.float16
+        self.task_start_token = '<s_pretrain>'
+        self.prompt_end_token = self.task_start_token
+        self.max_position_embeddings = cfg.model.text_decoder.max_length
+        self.text_anno_fn = False
+        self.tokenizer = TokenizerHF(cfg.tokenizer)
+        special_tokens = ['<sep/>', self.task_start_token, self.prompt_end_token]
+        newly_added_num = self.tokenizer.trunk.add_special_tokens({'additional_special_tokens': sorted(set(special_tokens))})
+        self.vocab_size = len(self.tokenizer.trunk)
+        preproc_fn = preprocess_text_anno if self.text_anno_fn else preprocess_ocr_anno
+        self.anno_preprocess_train = partial(preproc_fn, tokenizer=self.tokenizer.trunk, max_position_embeddings=self.max_position_embeddings, task_start_token=self.task_start_token, prompt_end_token=self.prompt_end_token)
+        self.model = Cruller(cfg.model)
+        if newly_added_num > 0:
+            self.model.text_decoder.trunk.resize_token_embeddings(len(self.tokenizer.trunk))
+        self.loss = nn.CrossEntropyLoss(ignore_index=-100)
+        self.has_no_sync = False
+        self.num_image_chs = 1 if cfg.model.image_encoder.image_fmt == 'L' else 3
+        img_mean = self.model.image_encoder.trunk.pretrained_cfg['mean']
+        img_std = self.model.image_encoder.trunk.pretrained_cfg['std']
+        self.img_mean = sum(img_mean) / len(img_mean) if cfg.model.image_encoder.image_fmt == 'L' else img_mean
+        self.img_std = sum(img_std) / len(img_std) if cfg.model.image_encoder.image_fmt == 'L' else img_std
+        self.image_preprocess_train = transforms.Compose([transforms.ToTensor(), transforms.Resize(cfg.model.image_encoder.image_size, interpolation=transforms.InterpolationMode.BICUBIC, antialias=True), transforms.Normalize(mean=self.img_mean, std=self.img_std)])
+        self.image_preprocess_eval = None
+        self.train_metrics = {}
+        self.eval_metrics = {}
+        self.max_recursion_length = 1000
+
+    def train_setup(self, num_batches_per_interval: int):
+        device = self.device_env.device
+        self.model.to(device)
+        if self.device_env.world_size > 1:
+            self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[device], static_graph=True)
+            self.has_no_sync = hasattr(self.model, 'no_sync')
+        opt_kwargs = {}
+        if self.cfg.opt.betas is not None:
+            opt_kwargs['betas'] = self.cfg.opt.betas
+        if self.cfg.opt.momentum is not None:
+            opt_kwargs['momentum'] = self.cfg.opt.momentum
+        self.optimizer = create_optimizer_v2(self.model, self.cfg.opt.optimizer, lr=self.cfg.opt.learning_rate, eps=self.cfg.opt.eps, layer_decay=self.cfg.opt.layer_decay, **opt_kwargs)
+        if self.cfg.amp:
+            self.scaler = timm.utils.NativeScaler()
+            self.autocast = partial(torch.autocast, device_type=device.type, dtype=self.amp_dtype)
+        else:
+            self.scaler = None
+            self.autocast = nullcontext
+        self.num_steps_per_interval = num_batches_per_interval // self.cfg.opt.grad_accum_steps
+        (self.scheduler, num_scheduled_epochs) = create_scheduler_v2(self.optimizer, self.cfg.opt.scheduler, warmup_lr=self.cfg.opt.warmup_learning_rate, warmup_epochs=self.num_warmup_intervals, num_epochs=self.num_intervals, step_on_epochs=False, updates_per_epoch=self.num_steps_per_interval)
+        self.scheduler.step_update(0)
+
+    def train_interval_start(self):
+        self.optimizer.zero_grad()
+        self.interval_batch_idx = 0
+
+    def train_interval_end(self):
+        self.monitor.log_phase('train', self.interval_idx)
+        self.interval_idx += 1
+
+    def train_step(self, sample):
+        (image_input, text_input, text_target) = sample
+        result = {}
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        text_input = text_input[:, :-1].to(self.device_env.device, non_blocking=True)
+        text_target = text_target[:, 1:].to(self.device_env.device, non_blocking=True)
+        accum_steps = self.cfg.opt.grad_accum_steps
+        need_update = (self.interval_batch_idx + 1) % accum_steps == 0
+
+        def _forward():
+            with self.autocast():
+                output = self.model(image_input, text_input)
+                logits = output['logits']
+                loss = self.loss(logits.view(-1, self.vocab_size), text_target.view(-1))
+            if accum_steps > 1:
+                loss /= accum_steps
+            return loss
+
+        def _backward(_loss):
+            if self.scaler is not None:
+                self.scaler(_loss, self.optimizer, clip_grad=self.cfg.opt.clip_grad_value, clip_mode=self.cfg.opt.clip_grad_mode, parameters=self.model.parameters(), need_update=need_update)
+            else:
+                _loss.backward()
+                if need_update:
+                    if self.cfg.opt.clip_grad_value is not None:
+                        timm.utils.dispatch_clip_grad(self.model.parameters(), value=self.cfg.opt.clip_grad_value, mode=self.cfg.opt.clip_grad_mode)
+                    self.optimizer.step()
+        if self.has_no_sync and (not need_update):
+            with self.model.no_sync():
+                loss = _forward()
+                _backward(loss)
+        else:
+            loss = _forward()
+            _backward(loss)
+        self.batch_idx += 1
+        self.interval_batch_idx += 1
+        if not need_update:
+            return result
+        self.step += 1
+        self.scheduler.step_update(self.step)
+        self.optimizer.zero_grad()
+        if self.step % self.eval_frequency == 0:
+            (metrics, eval_gallery) = self.get_train_ocr_metrics(sample)
+            self.train_metrics |= metrics
+            self.monitor.log_step('train', step_idx=self.step, step_end_idx=self.num_intervals * self.num_steps_per_interval, interval=self.interval_idx, loss=loss.item(), lr=self.get_current_lr(), metrics=self.train_metrics, eval_data=eval_gallery)
+        return result
+
+    def get_train_ocr_metrics(self, sample):
+        metrics = {}
+        eval_data = {}
+        (image_input, text_input, text_target) = sample
+        image_input = image_input.to(self.device_env.device, non_blocking=True)
+        text_input = text_input[:, :-1].to(self.device_env.device, non_blocking=True)
+        text_target = text_target[:, 1:].to(self.device_env.device, non_blocking=True)
+        ''
+        (ocr_metrics, ocr_reconstructed_sample) = get_ocr_metrics(model=self.model, tokenizer=self.tokenizer, image_input=image_input, text_input=text_target, device_env=self.device_env, max_recursion_length=self.max_recursion_length)
+        if ocr_metrics and ocr_reconstructed_sample:
+            metrics['ocr_reconstruction'] = ocr_metrics
+            eval_data['ocr_reconstruction_data'] = ocr_reconstructed_sample
+        else:
+            _logger.info("Can't generate text from current batch. Skipping metrics...")
+        return (metrics, eval_data)
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        state_dicts['optimizer'] = self.optimizer.state_dict()
+        if hasattr(self.scheduler, 'state_dict'):
+            state_dicts['scheduler'] = self.scheduler.state_dict()
+        if self.scaler is not None:
+            state_dicts['scaler'] = self.scaler.state_dict()
+        return state_dicts
+
+    def load_state_dict(self, state_dict):
+        pass
+
+    def __repr__(self):
+        outputs = [f'model: {repr(self.model)}', f'opt: {repr(self.optimizer)}', f'sched: {repr(self.scheduler)}']
+        return '\n'.join(outputs)
+
+# File: pixparse-main/src/pixparse/task/task_donut_eval_ocr.py
+from PIL import Image
+import re
+from transformers import DonutProcessor, VisionEncoderDecoderModel
+import torch
+from dataclasses import dataclass
+from functools import partial
+from pixparse.framework import TaskEvalCfg, TaskEval, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.data import preprocess_text_anno
+from pixparse.utils import get_ocr_metrics
+from pixparse.utils.ocr_utils import get_cer_wer_metrics
+import jiwer.transforms as tr
+import torch
+import torchvision.transforms as transforms
+import numpy as np
+
+@dataclass
+class TaskDonutEvalOCRCfg(TaskEvalCfg):
+
+    def __post_init__(self):
+        pass
+
+class TaskDonutEvalOCR(TaskEval):
+
+    def __init__(self, cfg: TaskDonutEvalOCRCfg, device_env: DeviceEnv, monitor: Monitor=None):
+        super().__init__(cfg=cfg, device_env=device_env, monitor=monitor)
+        self.cfg = cfg
+        self.processor = DonutProcessor.from_pretrained('naver-clova-ix/donut-base-finetuned-cord-v2')
+        self.model = VisionEncoderDecoderModel.from_pretrained('naver-clova-ix/donut-base-finetuned-cord-v2')
+        self.task_prompt = '<s_cord-v2>'
+        self.decoder_input_ids = self.processor.tokenizer(self.task_prompt, add_special_tokens=False, return_tensors='pt').input_ids
+        self.vocab_size = len(self.processor.tokenizer)
+        preproc_fn = preprocess_text_anno
+        self.max_position_embeddings = 768
+        self.anno_preprocess_eval = partial(preproc_fn, tokenizer=self.processor.tokenizer, max_position_embeddings=self.max_position_embeddings, task_start_token='', prompt_end_token=self.task_prompt)
+        self.model.eval()
+        self.has_no_sync = False
+        self.num_image_chs = 3
+        self.image_preprocess_eval = lambda x: x
+        self.cer_transforms = tr.Compose([tr.RemoveSpecificWords('<pad>'), tr.Strip(), tr.ReduceToListOfListOfChars()])
+        self.wer_transforms = tr.Compose([tr.RemoveSpecificWords('<pad>'), tr.RemoveMultipleSpaces(), tr.Strip(), tr.ReduceToListOfListOfWords()])
+        self.eval_metrics = {}
+        self.max_recursion_length = 1000
+
+    def setup(self):
+        device = self.device_env.device
+        self.model.to(device)
+
+    def prepare_for_evaluation(self, loaders):
+        loaders = {loader_key: loader for (loader_key, loader) in loaders.items() if loader_key in ['eval', 'eval_FUNSD']}
+        return loaders
+
+    def clean_text(self, text: str) -> str:
+        sequence = text.replace(self.processor.tokenizer.eos_token, '').replace(self.processor.tokenizer.pad_token, '')
+        cleaned_text = re.sub('<.*?>', '', sequence)
+        return cleaned_text
+
+    def step(self, sample):
+        metrics = {}
+        (image_input, text_input, text_target) = sample
+        text_input = [item[0] for item in text_input]
+        text_input = torch.stack(text_input, dim=0).to(self.device_env.device, non_blocking=True)
+        text_target = [item[0] for item in text_target]
+        text_target = torch.stack(text_target, dim=0).to(self.device_env.device, non_blocking=True)
+        decoder_input_ids = self.processor.tokenizer(self.task_prompt, add_special_tokens=False, return_tensors='pt').input_ids
+        pixel_values = self.processor([im.convert('RGB') for im in image_input], return_tensors='pt').pixel_values
+        with torch.inference_mode():
+            outputs = [self.model.generate(pixel_value.unsqueeze(0).to(self.device_env.device), decoder_input_ids=decoder_input_ids.to(self.device_env.device), max_length=self.max_position_embeddings, early_stopping=True, pad_token_id=self.processor.tokenizer.pad_token_id, eos_token_id=self.processor.tokenizer.eos_token_id, use_cache=True, num_beams=1, bad_words_ids=[[self.processor.tokenizer.unk_token_id]], return_dict_in_generate=True) for pixel_value in pixel_values]
+        generated_text = [self.clean_text(self.processor.decode(greedy_outputs.sequences[0])) for greedy_outputs in outputs]
+        text_input[text_input == -100] = self.processor.tokenizer.pad_token_id
+        raw_decoded_texts = self.processor.tokenizer.batch_decode(text_input)
+        decoded_texts = [self.clean_text(t) for t in raw_decoded_texts]
+        filtered = [(ref, pred) for (ref, pred) in zip(decoded_texts, generated_text) if ref and pred]
+        if not filtered:
+            return (None, None)
+        (decoded_texts, ocr_predictions) = zip(*filtered)
+        decoded_texts = list(decoded_texts)
+        ocr_predictions = list(ocr_predictions)
+        ocr_predictions = [text[0:len(reftext)] for (text, reftext) in zip(ocr_predictions, decoded_texts)]
+        metrics['ocr_reconstruction'] = get_cer_wer_metrics(self.cer_transforms, self.wer_transforms, dict(), ocr_predictions, decoded_texts)
+        return metrics
+
+    def average_metrics(self, metrics: dict):
+        wer_sum = 0
+        cer_sum = 0
+        for batch_metrics in metrics.values():
+            wer_sum += batch_metrics['ocr_reconstruction']['wer']
+            cer_sum += batch_metrics['ocr_reconstruction']['cer']
+        num_batches = len(metrics)
+        average_wer = wer_sum / num_batches
+        average_cer = cer_sum / num_batches
+        return {'ocr_reconstruction': {'wer': average_wer, 'cer': average_cer}}
+
+    def end(self):
+        pass
+
+    def state_dict(self):
+        state_dicts = {}
+        state_dicts['model'] = self.model.state_dict()
+        return state_dicts
+
+# File: pixparse-main/src/pixparse/task/task_factory.py
+import logging
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+import torch
+import torchvision.transforms as transforms
+from pixparse.framework import TaskEvalCfg, TaskEval, DeviceEnv, Monitor
+from pixparse.models import Cruller, ModelCfg, get_model_config
+from pixparse.tokenizers import TokenizerHF, TokenizerCfg
+from pixparse.data import preprocess_text_anno
+from pixparse.utils import get_ocr_metrics
+from pixparse.task import TaskCrullerEvalOCR, TaskCrullerEvalOCRCfg, TaskDonutEvalOCR, TaskDonutEvalOCRCfg, TaskCrullerEvalRVLCDIP, TaskCrullerEvalRVLCDIPCfg, TaskCrullerEvalCORD, TaskCrullerEvalCORDCfg, TaskCrullerEvalDOCVQA, TaskCrullerEvalDOCVQACfg, TaskCrullerPretrain, TaskCrullerPretrainCfg, TaskCrullerFinetuneRVLCDIP, TaskCrullerFinetuneRVLCDIPCfg, TaskCrullerFinetuneCORD, TaskCrullerFinetuneCORDCfg, TaskCrullerFinetuneDOCVQA, TaskCrullerFinetuneDOCVQACfg, TaskCrullerFinetuneXent, TaskCrullerFinetuneXentCfg
+
+class TaskFactory:
+    TASK_CLASS_REGISTRY = {'cruller_eval_ocr': (TaskCrullerEvalOCR, TaskCrullerEvalOCRCfg), 'cruller_eval_rvlcdip': (TaskCrullerEvalRVLCDIP, TaskCrullerEvalRVLCDIPCfg), 'cruller_eval_cord': (TaskCrullerEvalCORD, TaskCrullerEvalCORDCfg), 'cruller_eval_docvqa': (TaskCrullerEvalDOCVQA, TaskCrullerEvalDOCVQACfg), 'donut_eval_ocr': (TaskDonutEvalOCR, TaskDonutEvalOCRCfg), 'cruller_pretrain': (TaskCrullerPretrain, TaskCrullerPretrainCfg), 'cruller_finetune_rvlcdip': (TaskCrullerFinetuneRVLCDIP, TaskCrullerFinetuneRVLCDIPCfg), 'cruller_finetune_cord': (TaskCrullerFinetuneCORD, TaskCrullerFinetuneCORDCfg), 'cruller_finetune_docvqa': (TaskCrullerFinetuneDOCVQA, TaskCrullerFinetuneDOCVQACfg), 'cruller_finetune_xent': (TaskCrullerFinetuneXent, TaskCrullerFinetuneXentCfg)}
+
+    @classmethod
+    def create_task(cls, task_name: str, task_args, device_env: DeviceEnv, monitor: Monitor):
+        task_name = task_name.lower()
+        if task_name not in cls.TASK_CLASS_REGISTRY:
+            raise ValueError(f'Unknown task type: {task_name}. Available tasks are {list(cls.TASK_CLASS_REGISTRY.keys())}')
+        task_cls = cls.TASK_CLASS_REGISTRY[task_name][0]
+        task_cfg = cls.TASK_CLASS_REGISTRY[task_name][1]
+        task_cfg_instance = task_cfg(**vars(task_args))
+        task_cls_instance = task_cls(cfg=task_cfg_instance, device_env=device_env, monitor=monitor)
+        return (task_cls_instance, task_cfg_instance)
+
+# File: pixparse-main/src/pixparse/tokenizers/config.py
+import copy
+import re
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+from simple_parsing.helpers import Serializable
+from pixparse.utils.name_utils import _natural_key, clean_name
+_TOKENIZER_CONFIG_PATHS = [Path(__file__).parent / f'configs/']
+_TOKENIZER_CONFIGS = {}
+
+@dataclass
+class TokenizerCfg(Serializable):
+    name: str = 'facebook/bart-large'
+    pretrained: bool = True
+
+def _scan_tokenizer_configs():
+    global _TOKENIZER_CONFIGS
+    config_ext = ('.json',)
+    config_files = []
+    for config_path in _TOKENIZER_CONFIG_PATHS:
+        if config_path.is_file() and config_path.suffix in config_ext:
+            config_files.append(config_path)
+        elif config_path.is_dir():
+            for ext in config_ext:
+                config_files.extend(config_path.glob(f'*{ext}'))
+    for cf in config_files:
+        tokenizer_cfg = TokenizerCfg.load(cf)
+        _TOKENIZER_CONFIGS[cf.stem] = tokenizer_cfg
+    _TOKENIZER_CONFIGS = {k: v for (k, v) in sorted(_TOKENIZER_CONFIGS.items(), key=lambda x: _natural_key(x[0]))}
+_scan_tokenizer_configs()
+
+def list_tokenizers():
+    return list(_TOKENIZER_CONFIGS.keys())
+
+def get_tokenizer_config(tokenizer_name):
+    tokenizer_name = clean_name(tokenizer_name)
+    cfg = _TOKENIZER_CONFIGS.get(tokenizer_name, None)
+    return copy.deepcopy(cfg)
+
+# File: pixparse-main/src/pixparse/tokenizers/tokenizer_hf.py
+from torch import nn as nn
+from pixparse.tokenizers.config import TokenizerCfg
+from transformers import AutoTokenizer
+
+def create_tokenizer(cfg: TokenizerCfg):
+    assert cfg.name
+    extra_kwargs = {}
+    tokenizer = AutoTokenizer.from_pretrained(cfg.name, **extra_kwargs)
+    return tokenizer
+
+class TokenizerHF(nn.Module):
+
+    def __init__(self, cfg: TokenizerCfg):
+        super().__init__()
+        self.trunk = create_tokenizer(cfg)
+