



"""simple docstring"""






import argparse
import json
import pickle
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
_lowercase				:				int   		=logging.get_logger(__name__)






def   snake_case__     (	__lowerCamelCase       :					str			):
			"""simple docstring"""
			lowerCamelCase__	:	str				=SwinConfig.from_pretrained(
			    '''microsoft/swin-tiny-patch4-window7-224'''							,	out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']			)
			lowerCamelCase__	:	List[Any]				=MaskFormerConfig(backbone_config=__lowerCamelCase			)

			lowerCamelCase__	:	List[str]				='''huggingface/label-files'''
			if "ade20k-full" in model_name:
						# this should be ok
						lowerCamelCase__	:	Dict				=847
						lowerCamelCase__	:	str				='''maskformer-ade20k-full-id2label.json'''
			elif "ade" in model_name:
						# this should be ok
						lowerCamelCase__	:	int				=150
						lowerCamelCase__	:	Tuple				='''ade20k-id2label.json'''
			elif "coco-stuff" in model_name:
						# this should be ok
						lowerCamelCase__	:	str				=171
						lowerCamelCase__	:	str				='''maskformer-coco-stuff-id2label.json'''
			elif "coco" in model_name:
						# TODO
						lowerCamelCase__	:	Any				=133
						lowerCamelCase__	:	Any				='''coco-panoptic-id2label.json'''
			elif "cityscapes" in model_name:
						# this should be ok
						lowerCamelCase__	:	Union[str, Any]				=19
						lowerCamelCase__	:	Any				='''cityscapes-id2label.json'''
			elif "vistas" in model_name:
						# this should be ok
						lowerCamelCase__	:	Tuple				=65
						lowerCamelCase__	:	int				='''mapillary-vistas-id2label.json'''

			lowerCamelCase__	:	Tuple				=json.load(open(hf_hub_download(__lowerCamelCase							,	__lowerCamelCase							,	repo_type='''dataset'''			)							,	'''r'''			)			)
			lowerCamelCase__	:	Tuple				={int(__lowerCamelCase			): v for k, v in idalabel.items()}

			return config






def   snake_case__     (	__lowerCamelCase       :					Tuple			):
			"""simple docstring"""
			lowerCamelCase__	:	int				=[]
			# stem
			# fmt: off
			rename_keys.append(('''backbone.patch_embed.proj.weight''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight''')			)
			rename_keys.append(('''backbone.patch_embed.proj.bias''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias''')			)
			rename_keys.append(('''backbone.patch_embed.norm.weight''', '''model.pixel_level_module.encoder.model.embeddings.norm.weight''')			)
			rename_keys.append(('''backbone.patch_embed.norm.bias''', '''model.pixel_level_module.encoder.model.embeddings.norm.bias''')			)
			# stages
			for i in range(len(config.backbone_config.depths			)			):
						for j in range(config.backbone_config.depths[i]			):
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm1.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm1.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.relative_position_index''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.proj.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.attn.proj.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm2.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.norm2.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc1.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc1.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc2.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.blocks.{j}.mlp.fc2.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias''')			)

						if i < 3:
									rename_keys.append((f'''backbone.layers.{i}.downsample.reduction.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.downsample.norm.weight''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight''')			)
									rename_keys.append((f'''backbone.layers.{i}.downsample.norm.bias''', f'''model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias''')			)
						rename_keys.append((f'''backbone.norm{i}.weight''', f'''model.pixel_level_module.encoder.hidden_states_norms.{i}.weight''')			)
						rename_keys.append((f'''backbone.norm{i}.bias''', f'''model.pixel_level_module.encoder.hidden_states_norms.{i}.bias''')			)

			# FPN
			rename_keys.append(('''sem_seg_head.layer_4.weight''', '''model.pixel_level_module.decoder.fpn.stem.0.weight''')			)
			rename_keys.append(('''sem_seg_head.layer_4.norm.weight''', '''model.pixel_level_module.decoder.fpn.stem.1.weight''')			)
			rename_keys.append(('''sem_seg_head.layer_4.norm.bias''', '''model.pixel_level_module.decoder.fpn.stem.1.bias''')			)
			for source_index, target_index in zip(range(3							,	0							,	-1			)							,	range(0							,	3			)			):
						rename_keys.append((f'''sem_seg_head.adapter_{source_index}.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight''')			)
						rename_keys.append((f'''sem_seg_head.adapter_{source_index}.norm.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight''')			)
						rename_keys.append((f'''sem_seg_head.adapter_{source_index}.norm.bias''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias''')			)
						rename_keys.append((f'''sem_seg_head.layer_{source_index}.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight''')			)
						rename_keys.append((f'''sem_seg_head.layer_{source_index}.norm.weight''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight''')			)
						rename_keys.append((f'''sem_seg_head.layer_{source_index}.norm.bias''', f'''model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias''')			)
			rename_keys.append(('''sem_seg_head.mask_features.weight''', '''model.pixel_level_module.decoder.mask_projection.weight''')			)
			rename_keys.append(('''sem_seg_head.mask_features.bias''', '''model.pixel_level_module.decoder.mask_projection.bias''')			)

			# Transformer decoder
			for idx in range(config.decoder_config.decoder_layers			):
						# self-attention out projection
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight''', f'''model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias''', f'''model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias''')			)
						# cross-attention out projection
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias''')			)
						# MLP 1
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight''', f'''model.transformer_module.decoder.layers.{idx}.fc1.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias''', f'''model.transformer_module.decoder.layers.{idx}.fc1.bias''')			)
						# MLP 2
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight''', f'''model.transformer_module.decoder.layers.{idx}.fc2.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias''', f'''model.transformer_module.decoder.layers.{idx}.fc2.bias''')			)
						# layernorm 1 (self-attention layernorm)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight''', f'''model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias''', f'''model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias''')			)
						# layernorm 2 (cross-attention layernorm)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias''', f'''model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias''')			)
						# layernorm 3 (final layernorm)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight''', f'''model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias''', f'''model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias''')			)

			rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.weight''', '''model.transformer_module.decoder.layernorm.weight''')			)
			rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.bias''', '''model.transformer_module.decoder.layernorm.bias''')			)

			# heads on top
			rename_keys.append(('''sem_seg_head.predictor.query_embed.weight''', '''model.transformer_module.queries_embedder.weight''')			)

			rename_keys.append(('''sem_seg_head.predictor.input_proj.weight''', '''model.transformer_module.input_projection.weight''')			)
			rename_keys.append(('''sem_seg_head.predictor.input_proj.bias''', '''model.transformer_module.input_projection.bias''')			)

			rename_keys.append(('''sem_seg_head.predictor.class_embed.weight''', '''class_predictor.weight''')			)
			rename_keys.append(('''sem_seg_head.predictor.class_embed.bias''', '''class_predictor.bias''')			)

			for i in range(3			):
						rename_keys.append((f'''sem_seg_head.predictor.mask_embed.layers.{i}.weight''', f'''mask_embedder.{i}.0.weight''')			)
						rename_keys.append((f'''sem_seg_head.predictor.mask_embed.layers.{i}.bias''', f'''mask_embedder.{i}.0.bias''')			)
			# fmt: on

			return rename_keys






def   snake_case__     (	__lowerCamelCase       :					Any							,	__lowerCamelCase       :					Optional[Any]							,	__lowerCamelCase       :					Optional[int]			):
			"""simple docstring"""
			lowerCamelCase__	:	Tuple				=dct.pop(__lowerCamelCase			)
			lowerCamelCase__	:	Any				=val






def   snake_case__     (	__lowerCamelCase       :					str							,	__lowerCamelCase       :					int			):
			"""simple docstring"""
			lowerCamelCase__	:	Any				=[int(backbone_config.embed_dim * 2**i			) for i in range(len(backbone_config.depths			)			)]
			for i in range(len(backbone_config.depths			)			):
						lowerCamelCase__	:	Any				=num_features[i]
						for j in range(backbone_config.depths[i]			):
									# fmt: off
									# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
									lowerCamelCase__	:	Dict				=state_dict.pop(f'''backbone.layers.{i}.blocks.{j}.attn.qkv.weight'''			)
									lowerCamelCase__	:	Optional[int]				=state_dict.pop(f'''backbone.layers.{i}.blocks.{j}.attn.qkv.bias'''			)
									# next, add query, keys and values (in that order) to the state dict
									lowerCamelCase__	:	Optional[int]				=in_proj_weight[:dim, :]
									lowerCamelCase__	:	Optional[Any]				=in_proj_bias[: dim]
									lowerCamelCase__	:	Optional[Any]				=in_proj_weight[
									    dim : dim * 2, :
									]
									lowerCamelCase__	:	str				=in_proj_bias[
									    dim : dim * 2
									]
									lowerCamelCase__	:	Any				=in_proj_weight[
									    -dim :, :
									]
									lowerCamelCase__	:	Optional[Any]				=in_proj_bias[-dim :]
									# fmt: on






def   snake_case__     (	__lowerCamelCase       :					Union[str, Any]							,	__lowerCamelCase       :					Union[str, Any]			):
			"""simple docstring"""
			lowerCamelCase__	:	Any				=config.decoder_config.hidden_size
			for idx in range(config.decoder_config.decoder_layers			):
						# read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
						lowerCamelCase__	:	str				=state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight'''			)
						lowerCamelCase__	:	Dict				=state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias'''			)
						# next, add query, keys and values (in that order) to the state dict
						lowerCamelCase__	:	Optional[Any]				=in_proj_weight[: hidden_size, :]
						lowerCamelCase__	:	int				=in_proj_bias[:config.hidden_size]
						lowerCamelCase__	:	Optional[Any]				=in_proj_weight[hidden_size : hidden_size * 2, :]
						lowerCamelCase__	:	Union[str, Any]				=in_proj_bias[hidden_size : hidden_size * 2]
						lowerCamelCase__	:	List[Any]				=in_proj_weight[-hidden_size :, :]
						lowerCamelCase__	:	int				=in_proj_bias[-hidden_size :]
						# read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
						lowerCamelCase__	:	Dict				=state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight'''			)
						lowerCamelCase__	:	Optional[Any]				=state_dict.pop(f'''sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias'''			)
						# next, add query, keys and values (in that order) to the state dict
						lowerCamelCase__	:	str				=in_proj_weight[: hidden_size, :]
						lowerCamelCase__	:	Any				=in_proj_bias[:config.hidden_size]
						lowerCamelCase__	:	List[Any]				=in_proj_weight[hidden_size : hidden_size * 2, :]
						lowerCamelCase__	:	Optional[Any]				=in_proj_bias[hidden_size : hidden_size * 2]
						lowerCamelCase__	:	Tuple				=in_proj_weight[-hidden_size :, :]
						lowerCamelCase__	:	Any				=in_proj_bias[-hidden_size :]
			# fmt: on






def   snake_case__     (	):
			"""simple docstring"""
			lowerCamelCase__	:	Union[str, Any]				='''http://images.cocodataset.org/val2017/000000039769.jpg'''
			lowerCamelCase__	:	str				=Image.open(requests.get(__lowerCamelCase							,	stream=__lowerCamelCase			).raw			)
			return im






@torch.no_grad()
def   snake_case__     (	__lowerCamelCase       :					str							,	__lowerCamelCase       :					str							,	__lowerCamelCase       :					str							,	__lowerCamelCase       :					bool = False			):
			"""simple docstring"""
			lowerCamelCase__	:	int				=get_maskformer_config(__lowerCamelCase			)

			# load original state_dict
			with open(__lowerCamelCase							,	'''rb'''			) as f:
						lowerCamelCase__	:	Dict				=pickle.load(__lowerCamelCase			)
			lowerCamelCase__	:	List[str]				=data['''model''']

			# for name, param in state_dict.items():
			#     print(name, param.shape)

			# rename keys
			lowerCamelCase__	:	Optional[Any]				=create_rename_keys(__lowerCamelCase			)
			for src, dest in rename_keys:
						rename_key(__lowerCamelCase							,	__lowerCamelCase							,	__lowerCamelCase			)
			read_in_swin_q_k_v(__lowerCamelCase							,	config.backbone_config			)
			read_in_decoder_q_k_v(__lowerCamelCase							,	__lowerCamelCase			)

			# update to torch tensors
			for key, value in state_dict.items():
						lowerCamelCase__	:	int				=torch.from_numpy(__lowerCamelCase			)

			# load 🤗 model
			lowerCamelCase__	:	List[str]				=MaskFormerForInstanceSegmentation(__lowerCamelCase			)
			model.eval()

			for name, param in model.named_parameters():
						print(__lowerCamelCase							,	param.shape			)

			lowerCamelCase__	:	int				=model.load_state_dict(__lowerCamelCase							,	strict=__lowerCamelCase			)
			assert missing_keys == [
			    "model.pixel_level_module.encoder.model.layernorm.weight",
			    "model.pixel_level_module.encoder.model.layernorm.bias",
			]
			assert len(__lowerCamelCase			) == 0, f'''Unexpected keys: {unexpected_keys}'''

			# verify results
			lowerCamelCase__	:	Optional[Any]				=prepare_img()
			if "vistas" in model_name:
						lowerCamelCase__	:	List[Any]				=65
			elif "cityscapes" in model_name:
						lowerCamelCase__	:	str				=65535
			else:
						lowerCamelCase__	:	Any				=255
			lowerCamelCase__	:	List[str]				=True if '''ade''' in model_name else False
			lowerCamelCase__	:	Dict				=MaskFormerImageProcessor(ignore_index=__lowerCamelCase							,	reduce_labels=__lowerCamelCase			)

			lowerCamelCase__	:	Tuple				=image_processor(__lowerCamelCase							,	return_tensors='''pt'''			)

			lowerCamelCase__	:	str				=model(**__lowerCamelCase			)

			print('''Logits:'''							,	outputs.class_queries_logits[0, :3, :3]			)

			if model_name == "maskformer-swin-tiny-ade":
						lowerCamelCase__	:	Optional[Any]				=torch.tensor(
						    [[3.63_53, -4.47_70, -2.60_65], [0.50_81, -4.23_94, -3.53_43], [2.19_09, -5.03_53, -1.93_23]]			)
			assert torch.allclose(outputs.class_queries_logits[0, :3, :3]							,	__lowerCamelCase							,	atol=1e-4			)
			print('''Looks ok!'''			)

			if pytorch_dump_folder_path is not None:
						print(f'''Saving model and image processor to {pytorch_dump_folder_path}'''			)
						Path(__lowerCamelCase			).mkdir(exist_ok=__lowerCamelCase			)
						model.save_pretrained(__lowerCamelCase			)
						image_processor.save_pretrained(__lowerCamelCase			)

			if push_to_hub:
						print('''Pushing model and image processor to the hub...'''			)
						model.push_to_hub(f'''nielsr/{model_name}'''			)
						image_processor.push_to_hub(f'''nielsr/{model_name}'''			)


if __name__ == "__main__":
		_lowercase				:				List[Any]   		=argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    "--model_name",
		    default="maskformer-swin-tiny-ade",
		    type=str,
		    help=("Name of the MaskFormer model you'd like to convert",),
		)
		parser.add_argument(
		    "--checkpoint_path",
		    default="/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl",
		    type=str,
		    help="Path to the original state dict (.pth file).",
		)
		parser.add_argument(
		    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
		)
		parser.add_argument(
		    "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
		)

		_lowercase				:				Dict   		=parser.parse_args()
		convert_maskformer_checkpoint(
		    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
		)









"""simple docstring"""






_lowercase				:				Optional[Any]   		=		{
    "Pillow": "Pillow<10.0.0",
    "accelerate": "accelerate>=0.20.3",
    "av": "av==9.2.0",
    "beautifulsoup4": "beautifulsoup4",
    "black": "black~=23.1",
    "codecarbon": "codecarbon==1.2.0",
    "cookiecutter": "cookiecutter==1.7.3",
    "dataclasses": "dataclasses",
    "datasets": "datasets!=2.5.0",
    "decord": "decord==0.6.0",
    "deepspeed": "deepspeed>=0.9.3",
    "diffusers": "diffusers",
    "dill": "dill<0.3.5",
    "evaluate": "evaluate>=0.2.0",
    "fairscale": "fairscale>0.3",
    "faiss-cpu": "faiss-cpu",
    "fastapi": "fastapi",
    "filelock": "filelock",
    "flax": "flax>=0.4.1,<=0.7.0",
    "ftfy": "ftfy",
    "fugashi": "fugashi>=1.0",
    "GitPython": "GitPython<3.1.19",
    "hf-doc-builder": "hf-doc-builder>=0.3.0",
    "huggingface-hub": "huggingface-hub>=0.14.1,<1.0",
    "importlib_metadata": "importlib_metadata",
    "ipadic": "ipadic>=1.0.0,<2.0",
    "isort": "isort>=5.5.4",
    "jax": "jax>=0.2.8,!=0.3.2,<=0.4.13",
    "jaxlib": "jaxlib>=0.1.65,<=0.4.13",
    "jieba": "jieba",
    "kenlm": "kenlm",
    "keras-nlp": "keras-nlp>=0.3.1",
    "librosa": "librosa",
    "nltk": "nltk",
    "natten": "natten>=0.14.6",
    "numpy": "numpy>=1.17",
    "onnxconverter-common": "onnxconverter-common",
    "onnxruntime-tools": "onnxruntime-tools>=1.4.2",
    "onnxruntime": "onnxruntime>=1.4.0",
    "opencv-python": "opencv-python",
    "optuna": "optuna",
    "optax": "optax>=0.0.8,<=0.1.4",
    "packaging": "packaging>=20.0",
    "parameterized": "parameterized",
    "phonemizer": "phonemizer",
    "protobuf": "protobuf",
    "psutil": "psutil",
    "pyyaml": "pyyaml>=5.1",
    "pydantic": "pydantic<2",
    "pytest": "pytest>=7.2.0",
    "pytest-timeout": "pytest-timeout",
    "pytest-xdist": "pytest-xdist",
    "python": "python>=3.8.0",
    "ray[tune]": "ray[tune]",
    "regex": "regex!=2019.12.17",
    "requests": "requests",
    "rhoknp": "rhoknp>=1.1.0,<1.3.1",
    "rjieba": "rjieba",
    "rouge-score": "rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1",
    "ruff": "ruff>=0.0.241,<=0.0.259",
    "sacrebleu": "sacrebleu>=1.4.12,<2.0.0",
    "sacremoses": "sacremoses",
    "safetensors": "safetensors>=0.3.1",
    "sagemaker": "sagemaker>=2.31.0",
    "scikit-learn": "scikit-learn",
    "sentencepiece": "sentencepiece>=0.1.91,!=0.1.92",
    "sigopt": "sigopt",
    "starlette": "starlette",
    "sudachipy": "sudachipy>=0.6.6",
    "sudachidict_core": "sudachidict_core>=20220729",
    "tensorflow-cpu": "tensorflow-cpu>=2.6,<2.14",
    "tensorflow": "tensorflow>=2.6,<2.14",
    "tensorflow-text": "tensorflow-text<2.14",
    "tf2onnx": "tf2onnx",
    "timeout-decorator": "timeout-decorator",
    "timm": "timm",
    "tokenizers": "tokenizers>=0.11.1,!=0.11.3,<0.14",
    "torch": "torch>=1.9,!=1.12.0",
    "torchaudio": "torchaudio",
    "torchvision": "torchvision",
    "pyctcdecode": "pyctcdecode>=0.4.0",
    "tqdm": "tqdm>=4.27",
    "unidic": "unidic>=1.0.2",
    "unidic_lite": "unidic_lite>=1.0.7",
    "urllib3": "urllib3<2.0.0",
    "uvicorn": "uvicorn",
}




