code: 
  
  
  
  
  """simple docstring"""
  
  import argparse
  import json
  from pathlib import Path
  
  import requests
  import torch
  from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
  from PIL import Image
  
  from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  __A 		=			logging.get_logger(__name__)
  
  
  
  def   UpperCamelCase__     (		):
  		snake_case		:						Any								=				DetaConfig(
  		    num_queries=900       ,     encoder_ffn_dim=2048       ,     decoder_ffn_dim=2048       ,     num_feature_levels=5       ,     assign_first_stage=lowercase__       ,     with_box_refine=lowercase__       ,     two_stage=lowercase__       ,     )
  
  		# set labels
  		snake_case		:						Tuple								=				91
  		snake_case		:						str								=				"huggingface/label-files"
  		snake_case		:						str								=				"coco-detection-id2label.json"
  		snake_case		:						List[Any]								=				json.load(open(cached_download(hf_hub_url(lowercase__       ,     lowercase__       ,     repo_type="dataset"   )   )       ,     "r"   )   )
  		snake_case		:						Any								=				{int(lowercase__   ): v for k, v in idalabel.items()}
  		snake_case		:						Optional[int]								=				idalabel
  		snake_case		:						List[Any]								=				{v: k for k, v in idalabel.items()}
  
  		return config
  
  
  
  def   UpperCamelCase__     (		lowercase__  :     Tuple   ):
  		snake_case		:						Optional[int]								=				[]
  
  		# stem
  		# fmt: off
  		rename_keys.append(("backbone.0.body.conv1.weight", "model.backbone.model.embedder.embedder.convolution.weight")   )
  		rename_keys.append(("backbone.0.body.bn1.weight", "model.backbone.model.embedder.embedder.normalization.weight")   )
  		rename_keys.append(("backbone.0.body.bn1.bias", "model.backbone.model.embedder.embedder.normalization.bias")   )
  		rename_keys.append(("backbone.0.body.bn1.running_mean", "model.backbone.model.embedder.embedder.normalization.running_mean")   )
  		rename_keys.append(("backbone.0.body.bn1.running_var", "model.backbone.model.embedder.embedder.normalization.running_var")   )
  		# stages
  		for stage_idx in range(len(config.backbone_config.depths   )   ):
  				for layer_idx in range(config.backbone_config.depths[stage_idx]   ):
  						# shortcut
  						if layer_idx == 0:
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var''',
  								    )   )
  						# 3 convs
  						for i in range(3   ):
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean''',
  								    )   )
  								rename_keys.append(
  								    (
  								        F'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var''',
  								        F'''model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var''',
  								    )   )
      # transformer encoder
  		for i in range(config.encoder_layers   ):
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight''', F'''model.encoder.layers.{i}.self_attn.sampling_offsets.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias''', F'''model.encoder.layers.{i}.self_attn.sampling_offsets.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.attention_weights.weight''', F'''model.encoder.layers.{i}.self_attn.attention_weights.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.attention_weights.bias''', F'''model.encoder.layers.{i}.self_attn.attention_weights.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.value_proj.weight''', F'''model.encoder.layers.{i}.self_attn.value_proj.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.value_proj.bias''', F'''model.encoder.layers.{i}.self_attn.value_proj.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.output_proj.weight''', F'''model.encoder.layers.{i}.self_attn.output_proj.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.self_attn.output_proj.bias''', F'''model.encoder.layers.{i}.self_attn.output_proj.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.norm1.weight''', F'''model.encoder.layers.{i}.self_attn_layer_norm.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.norm1.bias''', F'''model.encoder.layers.{i}.self_attn_layer_norm.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.linear1.weight''', F'''model.encoder.layers.{i}.fc1.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.linear1.bias''', F'''model.encoder.layers.{i}.fc1.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.linear2.weight''', F'''model.encoder.layers.{i}.fc2.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.linear2.bias''', F'''model.encoder.layers.{i}.fc2.bias''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.norm2.weight''', F'''model.encoder.layers.{i}.final_layer_norm.weight''')   )
  				rename_keys.append((F'''transformer.encoder.layers.{i}.norm2.bias''', F'''model.encoder.layers.{i}.final_layer_norm.bias''')   )
  
  		# transformer decoder
  		for i in range(config.decoder_layers   ):
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight''', F'''model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias''', F'''model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.attention_weights.weight''', F'''model.decoder.layers.{i}.encoder_attn.attention_weights.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.attention_weights.bias''', F'''model.decoder.layers.{i}.encoder_attn.attention_weights.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.value_proj.weight''', F'''model.decoder.layers.{i}.encoder_attn.value_proj.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.value_proj.bias''', F'''model.decoder.layers.{i}.encoder_attn.value_proj.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.output_proj.weight''', F'''model.decoder.layers.{i}.encoder_attn.output_proj.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.cross_attn.output_proj.bias''', F'''model.decoder.layers.{i}.encoder_attn.output_proj.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.norm1.weight''', F'''model.decoder.layers.{i}.encoder_attn_layer_norm.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.norm1.bias''', F'''model.decoder.layers.{i}.encoder_attn_layer_norm.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''', F'''model.decoder.layers.{i}.self_attn.out_proj.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', F'''model.decoder.layers.{i}.self_attn.out_proj.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.norm2.weight''', F'''model.decoder.layers.{i}.self_attn_layer_norm.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.norm2.bias''', F'''model.decoder.layers.{i}.self_attn_layer_norm.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.linear1.weight''', F'''model.decoder.layers.{i}.fc1.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.linear1.bias''', F'''model.decoder.layers.{i}.fc1.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.linear2.weight''', F'''model.decoder.layers.{i}.fc2.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.linear2.bias''', F'''model.decoder.layers.{i}.fc2.bias''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.norm3.weight''', F'''model.decoder.layers.{i}.final_layer_norm.weight''')   )
  				rename_keys.append((F'''transformer.decoder.layers.{i}.norm3.bias''', F'''model.decoder.layers.{i}.final_layer_norm.bias''')   )
  
  		# fmt: on
  
  		return rename_keys
  
  
  
  def   UpperCamelCase__     (		lowercase__  :     str       ,     lowercase__  :     List[str]       ,     lowercase__  :     Optional[Any]   ):
  		snake_case		:						Union[str, Any]								=				dct.pop(lowercase__   )
  		snake_case		:						int								=				val
  
  
  
  def   UpperCamelCase__     (		lowercase__  :     List[str]       ,     lowercase__  :     Tuple   ):
  		# transformer decoder self-attention layers
  		snake_case		:						List[Any]								=				config.d_model
  		for i in range(config.decoder_layers   ):
  				# read in weights + bias of input projection layer of self-attention
  				snake_case		:						Tuple								=				state_dict.pop(F'''transformer.decoder.layers.{i}.self_attn.in_proj_weight'''   )
  				snake_case		:						Tuple								=				state_dict.pop(F'''transformer.decoder.layers.{i}.self_attn.in_proj_bias'''   )
  				# next, add query, keys and values (in that order) to the state dict
  				snake_case		:						Optional[int]								=				in_proj_weight[:hidden_size, :]
  				snake_case		:						str								=				in_proj_bias[:hidden_size]
  				snake_case		:						Optional[Any]								=				in_proj_weight[
  				    hidden_size : hidden_size * 2, :
  				]
  				snake_case		:						Optional[Any]								=				in_proj_bias[hidden_size : hidden_size * 2]
  				snake_case		:						List[str]								=				in_proj_weight[-hidden_size:, :]
  				snake_case		:						Optional[Any]								=				in_proj_bias[-hidden_size:]
  
  
  
  def   UpperCamelCase__     (		):
  		snake_case		:						List[Any]								=				"http://images.cocodataset.org/val2017/000000039769.jpg"
  		snake_case		:						Union[str, Any]								=				Image.open(requests.get(lowercase__       ,     stream=lowercase__   ).raw   )
  
  		return im
  
  
  
  @torch.no_grad()
  def   UpperCamelCase__     (		lowercase__  :     Dict       ,     lowercase__  :     Tuple       ,     lowercase__  :     Optional[int]   ):
  		snake_case		:						Tuple								=				get_deta_config()
  
  		# load original state dict
  		if model_name == "deta-resnet-50":
  				snake_case		:						Tuple								=				"adet_checkpoint0011.pth"
  		elif model_name == "deta-resnet-50-24-epochs":
  				snake_case		:						Optional[Any]								=				"adet_2x_checkpoint0023.pth"
  		else:
  				raise ValueError(F'''Model name {model_name} not supported'''   )
  		snake_case		:						Union[str, Any]								=				hf_hub_download(repo_id="nielsr/deta-checkpoints"       ,     filename=lowercase__   )
  		snake_case		:						Dict								=				torch.load(lowercase__       ,     map_location="cpu"   )["model"]
  
  		# rename keys
  		snake_case		:						List[Any]								=				create_rename_keys(lowercase__   )
  		for src, dest in rename_keys:
  				rename_key(lowercase__       ,     lowercase__       ,     lowercase__   )
  		read_in_decoder_q_k_v(lowercase__       ,     lowercase__   )
  
  		# fix some prefixes
  		for key in state_dict.copy().keys():
  				if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
  						snake_case		:						Any								=				state_dict.pop(lowercase__   )
  						snake_case		:						Union[str, Any]								=				val
  				if "input_proj" in key:
  						snake_case		:						Optional[int]								=				state_dict.pop(lowercase__   )
  						snake_case		:						List[Any]								=				val
  				if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
  						snake_case		:						List[Any]								=				state_dict.pop(lowercase__   )
  						snake_case		:						int								=				val
  
      # finally, create HuggingFace model and load state dict
  		snake_case		:						List[Any]								=				DetaForObjectDetection(lowercase__   )
  		model.load_state_dict(lowercase__   )
  		model.eval()
  
  		snake_case		:						Optional[Any]								=				"cuda" if torch.cuda.is_available() else "cpu"
  		model.to(lowercase__   )
  
  		# load image processor
  		snake_case		:						Any								=				DetaImageProcessor(format="coco_detection"   )
  
  		# verify our conversion on image
  		snake_case		:						List[Any]								=				prepare_img()
  		snake_case		:						str								=				processor(images=lowercase__       ,     return_tensors="pt"   )
  		snake_case		:						Union[str, Any]								=				encoding["pixel_values"]
  		snake_case		:						Union[str, Any]								=				model(pixel_values.to(lowercase__   )   )
  
  		# verify logits
  		if model_name == "deta-resnet-50":
  				snake_case		:						str								=				torch.tensor(
  				    [[-7.39_78, -2.54_06, -4.16_68], [-8.26_84, -3.99_33, -3.80_96], [-7.05_15, -3.79_73, -5.85_16]]   )
  				snake_case		:						Union[str, Any]								=				torch.tensor([[0.50_43, 0.49_73, 0.99_98], [0.25_42, 0.54_89, 0.47_48], [0.54_90, 0.27_65, 0.05_70]]   )
  		elif model_name == "deta-resnet-50-24-epochs":
  				snake_case		:						int								=				torch.tensor(
  				    [[-7.16_88, -2.48_57, -4.86_69], [-7.86_30, -3.81_54, -4.26_74], [-7.27_30, -4.18_65, -5.53_23]]   )
  				snake_case		:						int								=				torch.tensor([[0.50_21, 0.49_71, 0.99_94], [0.25_46, 0.54_86, 0.47_31], [0.16_86, 0.19_86, 0.21_42]]   )
  
  		assert torch.allclose(outputs.logits[0, :3, :3]       ,     expected_logits.to(lowercase__   )       ,     atol=1E-4   )
  		assert torch.allclose(outputs.pred_boxes[0, :3, :3]       ,     expected_boxes.to(lowercase__   )       ,     atol=1E-4   )
  		print("Everything ok!"   )
  
  		if pytorch_dump_folder_path:
  				# Save model and processor
  				logger.info(F'''Saving PyTorch model and processor to {pytorch_dump_folder_path}...'''   )
  				Path(lowercase__   ).mkdir(exist_ok=lowercase__   )
  				model.save_pretrained(lowercase__   )
  				processor.save_pretrained(lowercase__   )
  
  		# Push to hub
  		if push_to_hub:
  				print("Pushing model and processor to hub..."   )
  				model.push_to_hub(F'''jozhang97/{model_name}'''   )
  				processor.push_to_hub(F'''jozhang97/{model_name}'''   )
  
  
  if __name__ == "__main__":
  							__A 		=			argparse.ArgumentParser()
  
  							parser.add_argument(
  							    "--model_name",
  							    type=str,
  							    default="deta-resnet-50",
  							    choices=["deta-resnet-50", "deta-resnet-50-24-epochs"],
  							    help="Name of the model you'd like to convert.",
  							)
  							parser.add_argument(
  							    "--pytorch_dump_folder_path",
  							    default=None,
  							    type=str,
  							    help="Path to the folder to output PyTorch model.",
  							)
  							parser.add_argument(
  							    "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
  							)
  							__A 		=			parser.parse_args()
  							convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  import textwrap
  
  import pyarrow as pa
  import pytest
  
  from datasets import Features, Image
  from datasets.packaged_modules.text.text import Text
  
  from ..utils import require_pil
  
  
  
  @pytest.fixture
  def   UpperCamelCase__     (		lowercase__  :     str   ):
  		snake_case		:						List[str]								=				tmp_path / "text.txt"
  		snake_case		:						Tuple								=				textwrap.dedent(
  		    "\\n        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\n        Second paragraph:\n        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n        "   )
  		with open(lowercase__       ,     "w"       ,     encoding="utf-8"   ) as f:
  				f.write(lowercase__   )
  		return str(lowercase__   )
  
  
  
  @pytest.fixture
  def   UpperCamelCase__     (		lowercase__  :     str       ,     lowercase__  :     Dict   ):
  		snake_case		:						Any								=				tmp_path / "text_with_image.txt"
  		with open(lowercase__       ,     "w"       ,     encoding="utf-8"   ) as f:
  				f.write(lowercase__   )
  		return str(lowercase__   )
  
  
  
  @pytest.mark.parametrize("keep_linebreaks"       ,     [True, False]   )
  def   UpperCamelCase__     (		lowercase__  :     Union[str, Any]       ,     lowercase__  :     Tuple   ):
  		with open(lowercase__       ,     encoding="utf-8"   ) as f:
  				snake_case		:						List[Any]								=				f.read().splitlines(keepends=lowercase__   )
  		snake_case		:						List[Any]								=				Text(keep_linebreaks=lowercase__       ,     encoding="utf-8"   )
  		snake_case		:						Optional[int]								=				text._generate_tables([[text_file]]   )
  		snake_case		:						int								=				pa.concat_tables([table for _, table in generator]   ).to_pydict()["text"]
  		assert generated_content == expected_content
  
  
  
  @require_pil
  def   UpperCamelCase__     (		lowercase__  :     Optional[Any]   ):
  		with open(lowercase__       ,     encoding="utf-8"   ) as f:
  				snake_case		:						Union[str, Any]								=				f.read().splitlines()[0]
  		snake_case		:						List[Any]								=				Text(encoding="utf-8"       ,     features=Features({"image": Image()}   )   )
  		snake_case		:						Tuple								=				text._generate_tables([[text_file_with_image]]   )
  		snake_case		:						List[str]								=				pa.concat_tables([table for _, table in generator]   )
  		assert pa_table.schema.field("image"   ).type == Image()()
  		snake_case		:						Optional[Any]								=				pa_table.to_pydict()["image"]
  		assert generated_content == [{"path": image_file, "bytes": None}]
  
  
  
  @pytest.mark.parametrize("sample_by"       ,     ["line", "paragraph", "document"]   )
  def   UpperCamelCase__     (		lowercase__  :     Union[str, Any]       ,     lowercase__  :     List[str]   ):
  		with open(lowercase__       ,     encoding="utf-8"   ) as f:
  				snake_case		:						Tuple								=				f.read()
  		if sample_by == "line":
  				snake_case		:						Optional[int]								=				expected_content.splitlines()
  		elif sample_by == "paragraph":
  				snake_case		:						str								=				expected_content.split("\n\n"   )
  		elif sample_by == "document":
  				snake_case		:						List[Any]								=				[expected_content]
  		snake_case		:						str								=				Text(sample_by=lowercase__       ,     encoding="utf-8"       ,     chunksize=100   )
  		snake_case		:						Optional[int]								=				text._generate_tables([[text_file]]   )
  		snake_case		:						Optional[Any]								=				pa.concat_tables([table for _, table in generator]   ).to_pydict()["text"]
  		assert generated_content == expected_content
  
  