
'''simple docstring'''







import datasets

from .evaluate import evaluate


__lowerCAmelCase   =       """\\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"""

__lowerCAmelCase   =       """\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"""

__lowerCAmelCase   =       """\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 UpperCAmelCase__      (					datasets.Metric      ):





  """simple docstring"""

  def     __lowercase						(						self :	List[str]			):


     '''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     __lowercase						(						self :	Optional[int]				,_a :	Optional[Any]				,_a :	int			):


     '''simple docstring'''






     _a							:      Optional[Any]     =  {prediction['''id''']: prediction['''prediction_text'''] for prediction in predictions}
     _a							:      Optional[int]     =  [
         {
             '''paragraphs''': [
                 {
                     '''qas''': [
                         {
                             '''answers''': [{'''text''': answer_text} for answer_text in ref['''answers''']['''text''']],
                             '''id''': ref['''id'''],
                         }
                         for ref in references
                     ]
                 }
             ]
         }
     ]
     _a							:      List[str]     =  evaluate(dataset=__lowercase				,predictions=__lowercase			)
     return score










"""simple docstring"""





import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCamelCase					      =   logging.get_logger(__name__)

_UpperCamelCase					      =   {
    'BAAI/AltCLIP': 'https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Optional[int]									=		"""altclip_text_model"""




				def __init__(  self	:Tuple    ,     __lowercase	:Dict=25_0002    ,     __lowercase	:Union[str, Any]=1024    ,     __lowercase	:Optional[int]=24    ,     __lowercase	:List[Any]=16    ,     __lowercase	:int=4096    ,     __lowercase	:Union[str, Any]="gelu"    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:Union[str, Any]=514    ,     __lowercase	:Dict=1    ,     __lowercase	:int=0.02    ,     __lowercase	:Optional[int]=0.02    ,     __lowercase	:Optional[Any]=1e-0_5    ,     __lowercase	:str=1    ,     __lowercase	:Tuple=0    ,     __lowercase	:List[str]=2    ,     __lowercase	:str="absolute"    ,     __lowercase	:Tuple=True    ,     __lowercase	:Optional[int]=768    ,     **__lowercase	:Union[str, Any]    ,     ):
											super().__init__(pad_token_id=__lowercase    ,     bos_token_id=__lowercase    ,     eos_token_id=__lowercase    ,     **__lowercase      )

											__lowerCamelCase   :   int       =vocab_size
											__lowerCamelCase   :   int       =hidden_size
											__lowerCamelCase   :   Dict       =num_hidden_layers
											__lowerCamelCase   :   Optional[int]       =num_attention_heads
											__lowerCamelCase   :   str       =hidden_act
											__lowerCamelCase   :   Optional[Any]       =intermediate_size
											__lowerCamelCase   :   Tuple       =hidden_dropout_prob
											__lowerCamelCase   :   str       =attention_probs_dropout_prob
											__lowerCamelCase   :   Optional[int]       =max_position_embeddings
											__lowerCamelCase   :   Dict       =type_vocab_size
											__lowerCamelCase   :   Tuple       =initializer_range
											__lowerCamelCase   :   int       =initializer_factor
											__lowerCamelCase   :   List[Any]       =layer_norm_eps
											__lowerCamelCase   :   List[Any]       =position_embedding_type
											__lowerCamelCase   :   str       =use_cache
											__lowerCamelCase   :   str       =project_dim

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							List[Any]									=		"""altclip_vision_model"""




				def __init__(  self	:Dict    ,     __lowercase	:Optional[int]=768    ,     __lowercase	:Dict=3072    ,     __lowercase	:Dict=512    ,     __lowercase	:Optional[Any]=12    ,     __lowercase	:Tuple=12    ,     __lowercase	:Optional[int]=3    ,     __lowercase	:Any=224    ,     __lowercase	:List[Any]=32    ,     __lowercase	:Optional[Any]="quick_gelu"    ,     __lowercase	:Optional[int]=1e-5    ,     __lowercase	:List[Any]=0.0    ,     __lowercase	:Dict=0.02    ,     __lowercase	:Optional[int]=1.0    ,     **__lowercase	:Dict    ,     ):
											super().__init__(**__lowercase      )

											__lowerCamelCase   :   Tuple       =hidden_size
											__lowerCamelCase   :   List[Any]       =intermediate_size
											__lowerCamelCase   :   int       =projection_dim
											__lowerCamelCase   :   Union[str, Any]       =num_hidden_layers
											__lowerCamelCase   :   Optional[int]       =num_attention_heads
											__lowerCamelCase   :   Tuple       =num_channels
											__lowerCamelCase   :   str       =patch_size
											__lowerCamelCase   :   str       =image_size
											__lowerCamelCase   :   str       =initializer_range
											__lowerCamelCase   :   Optional[int]       =initializer_factor
											__lowerCamelCase   :   int       =attention_dropout
											__lowerCamelCase   :   Dict       =layer_norm_eps
											__lowerCamelCase   :   Optional[Any]       =hidden_act




				@classmethod
				def        __lowercase	(  cls	:str    ,     __lowercase	:Union[str, os.PathLike]    ,     **__lowercase	:Dict      ):
											cls._set_token_in_kwargs(__lowercase      )

											__lowerCamelCase     ,    __lowerCamelCase   :   List[Any]       =cls.get_config_dict(__lowercase    ,     **__lowercase      )

											# get the vision config dict if we are loading from AltCLIPConfig
											if config_dict.get('''model_type'''      ) == "altclip":
																		__lowerCamelCase   :   str       =config_dict['''vision_config''']

											if "model_type" in config_dict and hasattr(cls    ,     '''model_type'''      ) and config_dict["model_type"] != cls.model_type:
																		logger.warning(
																		    f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
																		    f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'      )

											return cls.from_dict(__lowercase    ,     **__lowercase      )

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Dict									=		"""altclip"""
				__snake_case :							Optional[Any]									=		True




				def __init__(  self	:Any    ,     __lowercase	:Union[str, Any]=None    ,     __lowercase	:str=None    ,     __lowercase	:Tuple=768    ,     __lowercase	:Any=2.6592    ,     **__lowercase	:Any      ):
											# If `_config_dict` exist, we use them for the backward compatibility.
											# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
											# of confusion!).
											__lowerCamelCase   :   Union[str, Any]       =kwargs.pop('''text_config_dict'''    ,     __lowercase      )
											__lowerCamelCase   :   List[str]       =kwargs.pop('''vision_config_dict'''    ,     __lowercase      )

											super().__init__(**__lowercase      )

											# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
											# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
											# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
											if text_config_dict is not None:
																		if text_config is None:
																									__lowerCamelCase   :   Any       ={}

																		# This is the complete result when using `text_config_dict`.
																		__lowerCamelCase   :   Any       =AltCLIPTextConfig(**__lowercase      ).to_dict()

																		# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
																		for key, value in _text_config_dict.items():
																									if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
																																# If specified in `text_config_dict`
																																if key in text_config_dict:
																																							__lowerCamelCase   :   Dict       =(
																																							    f'`{key}` is found in both `text_config_dict` and `text_config` but with different values. '
																																							    f'The value `text_config_dict["{key}"]` will be used instead.'
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							__lowerCamelCase   :   Dict       =(
																																							    f'`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '
																																							    f'value `text_config["{key}"]` will be overriden.'
																																							)
																																logger.warning(__lowercase      )

            # Update all values in `text_config` with the ones in `_text_config_dict`.
																		text_config.update(_text_config_dict      )

											if vision_config_dict is not None:
																		if vision_config is None:
																									__lowerCamelCase   :   int       ={}

																		# This is the complete result when using `vision_config_dict`.
																		__lowerCamelCase   :   Dict       =AltCLIPVisionConfig(**__lowercase      ).to_dict()
																		# convert keys to string instead of integer
																		if "id2label" in _vision_config_dict:
																									__lowerCamelCase   :   Any       ={
																									    str(__lowercase      ): value for key, value in _vision_config_dict['''id2label'''].items()
																									}

																		# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
																		for key, value in _vision_config_dict.items():
																									if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
																																# If specified in `vision_config_dict`
																																if key in vision_config_dict:
																																							__lowerCamelCase   :   List[str]       =(
																																							    f'`{key}` is found in both `vision_config_dict` and `vision_config` but with different '
																																							    f'values. The value `vision_config_dict["{key}"]` will be used instead.'
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							__lowerCamelCase   :   Union[str, Any]       =(
																																							    f'`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '
																																							    f'The value `vision_config["{key}"]` will be overriden.'
																																							)
																																logger.warning(__lowercase      )

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
																		vision_config.update(_vision_config_dict      )

											if text_config is None:
																		__lowerCamelCase   :   Any       ={}
																		logger.info('''`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.'''      )

											if vision_config is None:
																		__lowerCamelCase   :   int       ={}
																		logger.info('''`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.'''      )

											__lowerCamelCase   :   Any       =AltCLIPTextConfig(**__lowercase      )
											__lowerCamelCase   :   Union[str, Any]       =AltCLIPVisionConfig(**__lowercase      )

											__lowerCamelCase   :   Tuple       =projection_dim
											__lowerCamelCase   :   Tuple       =logit_scale_init_value
											__lowerCamelCase   :   Tuple       =1.0




				@classmethod
				def        __lowercase	(  cls	:Union[str, Any]    ,     __lowercase	:AltCLIPTextConfig    ,     __lowercase	:AltCLIPVisionConfig    ,     **__lowercase	:List[str]      ):
											return cls(text_config=text_config.to_dict()    ,     vision_config=vision_config.to_dict()    ,     **__lowercase      )




				def        __lowercase	(  self	:List[str]      ):
											__lowerCamelCase   :   int       =copy.deepcopy(self.__dict__      )
											__lowerCamelCase   :   int       =self.text_config.to_dict()
											__lowerCamelCase   :   int       =self.vision_config.to_dict()
											__lowerCamelCase   :   Optional[int]       =self.__class__.model_type
											return output




