



"""simple docstring"""
import argparse
import json

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

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling

def       _snake_case						(						UpperCamelCase						:		Tuple						):
 UpperCAmelCase	:					Tuple	=	[2, 2, 6, 2] if """tiny""" in model_name else [2, 2, 18, 2]
 UpperCAmelCase	:					List[str]	=	True if """large""" in model_name or """huge""" in model_name else False
 UpperCAmelCase	:					List[Any]	=	True if """large""" in model_name or """huge""" in model_name else False
 UpperCAmelCase	:					Tuple	=	True if """large""" in model_name or """huge""" in model_name else False

 if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
  if "fl3" in model_name:
   UpperCAmelCase	:					Union[str, Any]	=	[3, 3, 3, 3]
   UpperCAmelCase	:					List[str]	=	[5, 5, 5, 5]
  elif "fl4" in model_name:
   UpperCAmelCase	:					List[str]	=	[4, 4, 4, 4]
   UpperCAmelCase	:					Optional[int]	=	[3, 3, 3, 3]

 if "tiny" in model_name or "small" in model_name or "base" in model_name:
  UpperCAmelCase	:					Any	=	[3, 3, 3, 3]
  if "lrf" in model_name:
   UpperCAmelCase	:					Optional[Any]	=	[3, 3, 3, 3]
  else:
   UpperCAmelCase	:					Any	=	[2, 2, 2, 2]

 if "tiny" in model_name:
  UpperCAmelCase	:					List[Any]	=	96
 elif "small" in model_name:
  UpperCAmelCase	:					Optional[int]	=	96
 elif "base" in model_name:
  UpperCAmelCase	:					Dict	=	128
 elif "large" in model_name:
  UpperCAmelCase	:					Dict	=	192
 elif "xlarge" in model_name:
  UpperCAmelCase	:					int	=	256
 elif "huge" in model_name:
  UpperCAmelCase	:					Union[str, Any]	=	352

 # set label information
 UpperCAmelCase	:					int	=	"""huggingface/label-files"""
 if "large" in model_name or "huge" in model_name:
  UpperCAmelCase	:					Optional[Any]	=	"""imagenet-22k-id2label.json"""
 else:
  UpperCAmelCase	:					int	=	"""imagenet-1k-id2label.json"""

 UpperCAmelCase	:					Optional[Any]	=	json.load(open(hf_hub_download(UpperCamelCase			,		UpperCamelCase			,		repo_type="""dataset"""						)			,		"""r"""						)						)
 UpperCAmelCase	:					List[str]	=	{int(UpperCamelCase						): v for k, v in idalabel.items()}
 UpperCAmelCase	:					Union[str, Any]	=	{v: k for k, v in idalabel.items()}

 UpperCAmelCase	:					List[str]	=	FocalNetConfig(
     embed_dim=UpperCamelCase			,		depths=UpperCamelCase			,		focal_levels=UpperCamelCase			,		focal_windows=UpperCamelCase			,		use_conv_embed=UpperCamelCase			,		idalabel=UpperCamelCase			,		labelaid=UpperCamelCase			,		use_post_layernorm=UpperCamelCase			,		use_layerscale=UpperCamelCase			,		)

 return config

def       _snake_case						(						UpperCamelCase						:		Dict						):
 if "patch_embed.proj" in name:
  UpperCAmelCase	:					Union[str, Any]	=	name.replace("""patch_embed.proj"""			,		"""embeddings.patch_embeddings.projection"""						)
 if "patch_embed.norm" in name:
  UpperCAmelCase	:					List[str]	=	name.replace("""patch_embed.norm"""			,		"""embeddings.norm"""						)
 if "layers" in name:
  UpperCAmelCase	:					Union[str, Any]	=	"""encoder.""" + name
 if "encoder.layers" in name:
  UpperCAmelCase	:					str	=	name.replace("""encoder.layers"""			,		"""encoder.stages"""						)
 if "downsample.proj" in name:
  UpperCAmelCase	:					Dict	=	name.replace("""downsample.proj"""			,		"""downsample.projection"""						)
 if "blocks" in name:
  UpperCAmelCase	:					Optional[int]	=	name.replace("""blocks"""			,		"""layers"""						)
 if "modulation.f.weight" in name or "modulation.f.bias" in name:
  UpperCAmelCase	:					List[str]	=	name.replace("""modulation.f"""			,		"""modulation.projection_in"""						)
 if "modulation.h.weight" in name or "modulation.h.bias" in name:
  UpperCAmelCase	:					List[str]	=	name.replace("""modulation.h"""			,		"""modulation.projection_context"""						)
 if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
  UpperCAmelCase	:					Tuple	=	name.replace("""modulation.proj"""			,		"""modulation.projection_out"""						)

 if name == "norm.weight":
  UpperCAmelCase	:					List[Any]	=	"""layernorm.weight"""
 if name == "norm.bias":
  UpperCAmelCase	:					int	=	"""layernorm.bias"""

 if "head" in name:
  UpperCAmelCase	:					Optional[Any]	=	name.replace("""head"""			,		"""classifier"""						)
 else:
  UpperCAmelCase	:					Optional[int]	=	"""focalnet.""" + name

 return name

def       _snake_case						(						UpperCamelCase						:		Any			,		UpperCamelCase						:		Optional[Any]			,		UpperCamelCase						:		Tuple=False						):
 # fmt: off
 UpperCAmelCase	:					Optional[Any]	=	{
     """focalnet-tiny""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth""",
     """focalnet-tiny-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth""",
     """focalnet-small""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth""",
     """focalnet-small-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth""",
     """focalnet-base""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth""",
     """focalnet-base-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth""",
     """focalnet-large-lrf-fl3""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth""",
     """focalnet-large-lrf-fl4""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth""",
     """focalnet-xlarge-lrf-fl3""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth""",
     """focalnet-xlarge-lrf-fl4""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth""",
 }
 # fmt: on

 UpperCAmelCase	:					Optional[int]	=	model_name_to_url[model_name]
 print("""Checkpoint URL: """			,		UpperCamelCase						)
 UpperCAmelCase	:					Tuple	=	torch.hub.load_state_dict_from_url(UpperCamelCase			,		map_location="""cpu"""						)["""model"""]

 # rename keys
 for key in state_dict.copy().keys():
  UpperCAmelCase	:					List[Any]	=	state_dict.pop(UpperCamelCase						)
  UpperCAmelCase	:					Tuple	=	val

 UpperCAmelCase	:					Optional[Any]	=	get_focalnet_config(UpperCamelCase						)
 UpperCAmelCase	:					Dict	=	FocalNetForImageClassification(UpperCamelCase						)
 model.eval()

 # load state dict
 model.load_state_dict(UpperCamelCase						)

 # verify conversion
 UpperCAmelCase	:					str	=	"""http://images.cocodataset.org/val2017/000000039769.jpg"""

 UpperCAmelCase	:					Optional[int]	=	BitImageProcessor(
     do_resize=UpperCamelCase			,		size={"""shortest_edge""": 256}			,		resample=PILImageResampling.BILINEAR			,		do_center_crop=UpperCamelCase			,		crop_size=224			,		do_normalize=UpperCamelCase			,		image_mean=UpperCamelCase			,		image_std=UpperCamelCase			,		)
 UpperCAmelCase	:					Any	=	Image.open(requests.get(UpperCamelCase			,		stream=UpperCamelCase						).raw						)
 UpperCAmelCase	:					Dict	=	processor(images=UpperCamelCase			,		return_tensors="""pt"""						)

 UpperCAmelCase	:					Optional[int]	=	transforms.Compose(
     [
         transforms.Resize(256						),
         transforms.CenterCrop(224						),
         transforms.ToTensor(),
         transforms.Normalize(mean=[0.485, 0.456, 0.406]			,		std=[0.229, 0.224, 0.225]						),
     ]						)

 UpperCAmelCase	:					List[Any]	=	image_transforms(UpperCamelCase						).unsqueeze(0						)

 # verify pixel_values
 assert torch.allclose(inputs.pixel_values			,		UpperCamelCase			,		atol=1e-4						)

 UpperCAmelCase	:					int	=	model(**UpperCamelCase						)

 UpperCAmelCase	:					Optional[int]	=	outputs.logits.argmax(-1						).item()
 print("""Predicted class:"""			,		model.config.idalabel[predicted_class_idx]						)

 print("""First values of logits:"""			,		outputs.logits[0, :3]						)

 if model_name == "focalnet-tiny":
  UpperCAmelCase	:					List[str]	=	torch.tensor([0.2166, -0.4368, 0.2191]						)
 elif model_name == "focalnet-tiny-lrf":
  UpperCAmelCase	:					Union[str, Any]	=	torch.tensor([1.1669, 0.0125, -0.1695]						)
 elif model_name == "focalnet-small":
  UpperCAmelCase	:					Union[str, Any]	=	torch.tensor([0.4917, -0.0430, 0.1341]						)
 elif model_name == "focalnet-small-lrf":
  UpperCAmelCase	:					Optional[int]	=	torch.tensor([-0.2588, -0.5342, -0.2331]						)
 elif model_name == "focalnet-base":
  UpperCAmelCase	:					Optional[int]	=	torch.tensor([-0.1655, -0.4090, -0.1730]						)
 elif model_name == "focalnet-base-lrf":
  UpperCAmelCase	:					Optional[int]	=	torch.tensor([0.5306, -0.0483, -0.3928]						)
 assert torch.allclose(outputs.logits[0, :3]			,		UpperCamelCase			,		atol=1e-4						)
 print("""Looks ok!"""						)

 if pytorch_dump_folder_path is not None:
  print(F"Saving model and processor of {model_name} to {pytorch_dump_folder_path}"						)
  model.save_pretrained(UpperCamelCase						)
  processor.save_pretrained(UpperCamelCase						)

 if push_to_hub:
  print(F"Pushing model and processor of {model_name} to the hub..."						)
  model.push_to_hub(F"{model_name}"						)
  processor.push_to_hub(F"{model_name}"						)


if __name__ == "__main__":
      A:   Optional[int]								=		argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          "--model_name",
          default="focalnet-tiny",
          type=str,
          help="Name of the FocalNet model you'd like to convert.",
      )
      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 to push the model and processor to the hub.",
      )

      A:   str								=		parser.parse_args()
      convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





"""simple docstring"""
import datasets

from .evaluate import evaluate


A:   Optional[Any]								=		"\\n@article{hendrycks2021cuad,\n      title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},\n      author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},\n      journal={arXiv preprint arXiv:2103.06268},\n      year={2021}\n}\n"

A:   Optional[int]								=		"\nThis metric wrap the official scoring script for version 1 of the Contract\nUnderstanding Atticus Dataset (CUAD).\nContract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510\ncommercial legal contracts that have been manually labeled to identify 41 categories of important\nclauses that lawyers look for when reviewing contracts in connection with corporate transactions.\n"

A:   int								=		"\nComputes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair as given in the references (see below)\n        - 'prediction_text': list of possible texts for the answer, as a list of strings\n        depending on a threshold on the confidence probability of each prediction.\n    references: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair (see above),\n        - 'answers': a Dict in the CUAD dataset format\n            {\n                'text': list of possible texts for the answer, as a list of strings\n                'answer_start': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    'exact_match': Exact match (the normalized answer exactly match the gold answer)\n    'f1': The F-score of predicted tokens versus the gold answer\n    'aupr': Area Under the Precision-Recall curve\n    'prec_at_80_recall': Precision at 80% recall\n    'prec_at_90_recall': Precision at 90% recall\nExamples:\n    >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]\n    >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]\n    >>> cuad_metric = datasets.load_metric(\"cuad\")\n    >>> results = cuad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0}\n"



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,			_KWARGS_DESCRIPTION )
class       SCREAMING_SNAKE_CASE__  (					datasets.Metric ):

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    return datasets.MetricInfo(
        description=_DESCRIPTION      ,     citation=_CITATION      ,     inputs_description=_KWARGS_DESCRIPTION      ,     features=datasets.Features(
            {
                """predictions""": {
                    """id""": datasets.Value("""string"""						),
                    """prediction_text""": datasets.features.Sequence(datasets.Value("""string"""						)						),
                },
                """references""": {
                    """id""": datasets.Value("""string"""						),
                    """answers""": datasets.features.Sequence(
                        {
                            """text""": datasets.Value("""string"""						),
                            """answer_start""": datasets.Value("""int32"""						),
                        }						),
                },
            }						)      ,     codebase_urls=["""https://www.atticusprojectai.org/cuad"""]      ,     reference_urls=["""https://www.atticusprojectai.org/cuad"""]      ,     )




   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	{prediction["""id"""]: prediction["""prediction_text"""] for prediction in predictions}
    UpperCAmelCase	:					Tuple	=	[
        {
            """paragraphs""": [
                {
                    """qas""": [
                        {
                            """answers""": [{"""text""": answer_text} for answer_text in ref["""answers"""]["""text"""]],
                            """id""": ref["""id"""],
                        }
                        for ref in references
                    ]
                }
            ]
        }
    ]
    UpperCAmelCase	:					Optional[Any]	=	evaluate(dataset=_SCREAMING_SNAKE_CASE      ,     predictions=_SCREAMING_SNAKE_CASE						)
    return score
