code: 
  
  
  import argparse
  import json
  import re
  import string
  import sys
  
  import numpy as np
  
  
  __a   				=      0.5
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase     )    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   List[Any]					   =		['''.''', ''',''', ''';''', ''':''']
  
        for token in remove_tokens:
              lowercase			:   List[str]					   =		ground_truth.replace(__a,    ''''''     )
              lowercase			:   Optional[int]					   =		prediction.replace(__a,    ''''''     )
  
        lowercase			:   str					   =		ground_truth.lower(), prediction.lower()
        lowercase			:   List[Any]					   =		ground_truth.replace('''/''',    ''' '''     ), prediction.replace('''/''',    ''' '''     )
        lowercase			:   Union[str, Any]					   =		set(ground_truth.split(''' '''     )     ), set(prediction.split(''' '''     )     )
  
        lowercase			:   Optional[int]					   =		ground_truth.intersection(__a     )
        lowercase			:   List[str]					   =		ground_truth.union(__a     )
        lowercase			:   Tuple					   =		len(__a     ) / len(__a     )
        return jaccard
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase     )    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        def remove_articles(_UpperCamelCase     ):
              return re.sub(R'''\b(a|an|the)\b''',    ''' ''',    __a     )
  
        def white_space_fix(_UpperCamelCase     ):
              return " ".join(text.split()     )
  
        def remove_punc(_UpperCamelCase     ):
              lowercase			:   Optional[int]					   =		set(string.punctuation     )
              return "".join(ch for ch in text if ch not in exclude     )
  
        def lower(_UpperCamelCase     ):
              return text.lower()
  
        return white_space_fix(remove_articles(remove_punc(lower(__a     )     )     )     )
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Optional[Any]					   =		0, 0, 0
  
        lowercase			:   Union[str, Any]					   =		'''Parties''' in qa_id
  
        # first check if ground truth is empty
        if len(__a     ) == 0:
              if len(__a     ) > 0:
                    fp += len(__a     )  # false positive for each one
        else:
              for ground_truth in ground_truths:
                    assert len(__a     ) > 0
                    # check if there is a match
                    lowercase			:   Dict					   =		False
                    for pred in predictions:
                          if substr_ok:
                                lowercase			:   Tuple					   =		get_jaccard(__a,    __a     ) >= IOU_THRESH or ground_truth in pred
                          else:
                                lowercase			:   Dict					   =		get_jaccard(__a,    __a     ) >= IOU_THRESH
                          if is_match:
                                lowercase			:   str					   =		True
  
                    if match_found:
                          tp += 1
                    else:
                          fn += 1
  
          # now also get any fps by looping through preds
              for pred in predictions:
                    # Check if there's a match. if so, don't count (don't want to double count based on the above)
                    # but if there's no match, then this is a false positive.
                    # (Note: we get the true positives in the above loop instead of this loop so that we don't double count
                    # multiple predictions that are matched with the same answer.)
                    lowercase			:   Any					   =		False
                    for ground_truth in ground_truths:
                          assert len(__a     ) > 0
                          if substr_ok:
                                lowercase			:   int					   =		get_jaccard(__a,    __a     ) >= IOU_THRESH or ground_truth in pred
                          else:
                                lowercase			:   Optional[Any]					   =		get_jaccard(__a,    __a     ) >= IOU_THRESH
                          if is_match:
                                lowercase			:   Any					   =		True
  
                    if not match_found:
                          fp += 1
  
        lowercase			:   int					   =		tp / (tp + fp) if tp + fp > 0 else np.nan
        lowercase			:   List[Any]					   =		tp / (tp + fn) if tp + fn > 0 else np.nan
  
        return precision, recall
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase     )    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   str					   =		precisions[::-1]
        for i in range(1,    len(__a     )     ):
              lowercase			:   int					   =		max(precision_best[i - 1],    precision_best[i]     )
        lowercase			:   List[Any]					   =		precision_best[::-1]
        return precisions
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase     )    ->Optional[Any]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   List[Any]					   =		process_precisions(__a     )
        lowercase			:   Optional[int]					   =		np.trapz(__a,    __a     )
        if np.isnan(__a     ):
              return 0
        return aupr
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->Dict:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   List[str]					   =		process_precisions(__a     )
        lowercase			:   List[Any]					   =		0
        for prec, recall in zip(__a,    __a     ):
              if recall >= recall_thresh:
                    lowercase			:   Optional[Any]					   =		prec
                    break
        return prec_at_recall
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase     )    ->Union[str, Any]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        return normalize_answer(__a     ) == normalize_answer(__a     )
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->Any:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Tuple					   =		0
        for pred in predictions:
              for ground_truth in ground_truths:
                    lowercase			:   int					   =		metric_fn(__a,    __a     )
                    if score == 1:  # break the loop when one prediction matches the ground truth
                          break
              if score == 1:
                    break
        return score
  
  
  
  
  def 			__lowercase	(      _UpperCamelCase,    _UpperCamelCase     )    ->str:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Any					   =		0
        lowercase			:   Union[str, Any]					   =		[]
        lowercase			:   Union[str, Any]					   =		[]
        for article in dataset:
              for paragraph in article["paragraphs"]:
                    for qa in paragraph["qas"]:
                          total += 1
                          if qa["id"] not in predictions:
                                lowercase			:   List[Any]					   =		'''Unanswered question ''' + qa['''id'''] + ''' will receive score 0.'''
                                print(__a,    file=sys.stderr     )
                                continue
                          lowercase			:   Any					   =		[x['''text'''] for x in qa['''answers''']]
                          lowercase			:   Optional[int]					   =		predictions[qa['''id''']]
                          lowercase			:   Optional[int]					   =		compute_precision_recall(__a,    __a,    qa['''id''']     )
  
                          precisions.append(__a     )
                          recalls.append(__a     )
  
                          if precision == 0 and recall == 0:
                                fa += 0
                          else:
                                fa += 2 * (precision * recall) / (precision + recall)
  
                          exact_match += metric_max_over_ground_truths(__a,    __a,    __a     )
  
        lowercase			:   Tuple					   =		[x for _, x in sorted(zip(__a,    __a     )     )]
        recalls.sort()
  
        lowercase			:   int					   =		1_0_0.0 * fa / total
        lowercase			:   List[str]					   =		1_0_0.0 * exact_match / total
        lowercase			:   List[Any]					   =		get_aupr(__a,    __a     )
  
        lowercase			:   Optional[Any]					   =		get_prec_at_recall(__a,    __a,    recall_thresh=0.9     )
        lowercase			:   int					   =		get_prec_at_recall(__a,    __a,    recall_thresh=0.8     )
  
        return {
            "exact_match": exact_match,
            "f1": fa,
            "aupr": aupr,
            "prec_at_80_recall": prec_at_aa_recall,
            "prec_at_90_recall": prec_at_aa_recall,
        }
  
  
  if __name__ == "__main__":
    __a   				=      argparse.ArgumentParser(description='''Evaluation for CUAD''')
    parser.add_argument('''dataset_file''', help='''Dataset file''')
    parser.add_argument('''prediction_file''', help='''Prediction File''')
    __a   				=      parser.parse_args()
    with open(args.dataset_file) as dataset_file:
      __a   				=      json.load(dataset_file)
      __a   				=      dataset_json['''data''']
    with open(args.prediction_file) as prediction_file:
      __a   				=      json.load(prediction_file)
    print(json.dumps(evaluate(dataset, predictions)))
  
  
style_context: 
  
  
  import argparse
  import os
  
  import align
  import numpy as np
  import requests
  import tensorflow as tf
  import torch
  from PIL import Image
  from tokenizer import Tokenizer
  
  from transformers import (
      AlignConfig,
      AlignModel,
      AlignProcessor,
      BertConfig,
      BertTokenizer,
      EfficientNetConfig,
      EfficientNetImageProcessor,
  )
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  __a   				=      logging.get_logger(__name__)
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->Tuple:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Optional[int]					   =		tf.image.resize(_UpperCamelCase,    (346, 346)     )
        lowercase			:   Any					   =		tf.image.crop_to_bounding_box(_UpperCamelCase,    (346 - 289) // 2,    (346 - 289) // 2,    289,    289     )
        return image
  
  
  
  
  def 			__lowercase	(						)    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Tuple					   =		EfficientNetConfig.from_pretrained('''google/efficientnet-b7'''     )
        lowercase			:   Optional[int]					   =		289
        lowercase			:   Optional[Any]					   =		640
        lowercase			:   Any					   =		{'''0''': '''LABEL_0''', '''1''': '''LABEL_1'''}
        lowercase			:   Optional[Any]					   =		{'''LABEL_0''': 0, '''LABEL_1''': 1}
        lowercase			:   Union[str, Any]					   =		[]
  
        lowercase			:   Union[str, Any]					   =		BertConfig()
        lowercase			:   Any					   =		AlignConfig.from_text_vision_configs(
            text_config=_UpperCamelCase,    vision_config=_UpperCamelCase,    projection_dim=640     )
        return config
  
  
  
  
  def 			__lowercase	(						)    ->Union[str, Any]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   int					   =		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
        lowercase			:   int					   =		Image.open(requests.get(_UpperCamelCase,    stream=_UpperCamelCase     ).raw     )
        return im
  
  
  
  
  def 			__lowercase	(						)    ->Optional[int]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   Any					   =		EfficientNetImageProcessor(
            do_center_crop=_UpperCamelCase,    rescale_factor=1 / 1_2_7.5,    rescale_offset=_UpperCamelCase,    do_normalize=_UpperCamelCase,    include_top=_UpperCamelCase,    resample=Image.BILINEAR,    )
        lowercase			:   Any					   =		BertTokenizer.from_pretrained('''bert-base-uncased'''     )
        lowercase			:   int					   =		64
        lowercase			:   List[Any]					   =		AlignProcessor(image_processor=_UpperCamelCase,    tokenizer=_UpperCamelCase     )
        return processor
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->int:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   str					   =		[v.split('''_'''     )[0].split('''block'''     )[1] for v in original_param_names if v.startswith('''block'''     )]
        lowercase			:   str					   =		list(set(_UpperCamelCase     )     )
        lowercase			:   List[str]					   =		sorted(_UpperCamelCase     )
        lowercase			:   str					   =		len(_UpperCamelCase     )
        lowercase			:   Dict					   =		{b: str(_UpperCamelCase     ) for b, i in zip(_UpperCamelCase,    range(_UpperCamelCase     )     )}
  
        lowercase			:   int					   =		[]
        rename_keys.append(('''stem_conv/kernel:0''', '''embeddings.convolution.weight''')     )
        rename_keys.append(('''stem_bn/gamma:0''', '''embeddings.batchnorm.weight''')     )
        rename_keys.append(('''stem_bn/beta:0''', '''embeddings.batchnorm.bias''')     )
        rename_keys.append(('''stem_bn/moving_mean:0''', '''embeddings.batchnorm.running_mean''')     )
        rename_keys.append(('''stem_bn/moving_variance:0''', '''embeddings.batchnorm.running_var''')     )
  
        for b in block_names:
              lowercase			:   Dict					   =		block_name_mapping[b]
              rename_keys.append((f"""block{b}_expand_conv/kernel:0""", f"""encoder.blocks.{hf_b}.expansion.expand_conv.weight""")     )
              rename_keys.append((f"""block{b}_expand_bn/gamma:0""", f"""encoder.blocks.{hf_b}.expansion.expand_bn.weight""")     )
              rename_keys.append((f"""block{b}_expand_bn/beta:0""", f"""encoder.blocks.{hf_b}.expansion.expand_bn.bias""")     )
              rename_keys.append(
                  (f"""block{b}_expand_bn/moving_mean:0""", f"""encoder.blocks.{hf_b}.expansion.expand_bn.running_mean""")     )
              rename_keys.append(
                  (f"""block{b}_expand_bn/moving_variance:0""", f"""encoder.blocks.{hf_b}.expansion.expand_bn.running_var""")     )
              rename_keys.append(
                  (f"""block{b}_dwconv/depthwise_kernel:0""", f"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight""")     )
              rename_keys.append((f"""block{b}_bn/gamma:0""", f"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight""")     )
              rename_keys.append((f"""block{b}_bn/beta:0""", f"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias""")     )
              rename_keys.append(
                  (f"""block{b}_bn/moving_mean:0""", f"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean""")     )
              rename_keys.append(
                  (f"""block{b}_bn/moving_variance:0""", f"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var""")     )
  
              rename_keys.append((f"""block{b}_se_reduce/kernel:0""", f"""encoder.blocks.{hf_b}.squeeze_excite.reduce.weight""")     )
              rename_keys.append((f"""block{b}_se_reduce/bias:0""", f"""encoder.blocks.{hf_b}.squeeze_excite.reduce.bias""")     )
              rename_keys.append((f"""block{b}_se_expand/kernel:0""", f"""encoder.blocks.{hf_b}.squeeze_excite.expand.weight""")     )
              rename_keys.append((f"""block{b}_se_expand/bias:0""", f"""encoder.blocks.{hf_b}.squeeze_excite.expand.bias""")     )
              rename_keys.append(
                  (f"""block{b}_project_conv/kernel:0""", f"""encoder.blocks.{hf_b}.projection.project_conv.weight""")     )
              rename_keys.append((f"""block{b}_project_bn/gamma:0""", f"""encoder.blocks.{hf_b}.projection.project_bn.weight""")     )
              rename_keys.append((f"""block{b}_project_bn/beta:0""", f"""encoder.blocks.{hf_b}.projection.project_bn.bias""")     )
              rename_keys.append(
                  (f"""block{b}_project_bn/moving_mean:0""", f"""encoder.blocks.{hf_b}.projection.project_bn.running_mean""")     )
              rename_keys.append(
                  (f"""block{b}_project_bn/moving_variance:0""", f"""encoder.blocks.{hf_b}.projection.project_bn.running_var""")     )
  
        lowercase			:   Union[str, Any]					   =		{}
        for item in rename_keys:
              if item[0] in original_param_names:
                    lowercase			:   Dict					   =		'''vision_model.''' + item[1]
  
      # BERT text encoder
        lowercase			:   str					   =		[]
        lowercase			:   Optional[Any]					   =		'''tf_bert_model/bert'''
        lowercase			:   str					   =		'''text_model'''
        for i in range(12     ):
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/self/query/kernel:0""",
                      f"""{new}.encoder.layer.{i}.attention.self.query.weight""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/self/query/bias:0""",
                      f"""{new}.encoder.layer.{i}.attention.self.query.bias""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/self/key/kernel:0""",
                      f"""{new}.encoder.layer.{i}.attention.self.key.weight""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/self/key/bias:0""",
                      f"""{new}.encoder.layer.{i}.attention.self.key.bias""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/self/value/kernel:0""",
                      f"""{new}.encoder.layer.{i}.attention.self.value.weight""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/self/value/bias:0""",
                      f"""{new}.encoder.layer.{i}.attention.self.value.bias""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/output/dense/kernel:0""",
                      f"""{new}.encoder.layer.{i}.attention.output.dense.weight""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/output/dense/bias:0""",
                      f"""{new}.encoder.layer.{i}.attention.output.dense.bias""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/output/LayerNorm/gamma:0""",
                      f"""{new}.encoder.layer.{i}.attention.output.LayerNorm.weight""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/attention/output/LayerNorm/beta:0""",
                      f"""{new}.encoder.layer.{i}.attention.output.LayerNorm.bias""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/intermediate/dense/kernel:0""",
                      f"""{new}.encoder.layer.{i}.intermediate.dense.weight""",
                  )     )
              rename_keys.append(
                  (
                      f"""{old}/encoder/layer_._{i}/intermediate/dense/bias:0""",
                      f"""{new}.encoder.layer.{i}.intermediate.dense.bias""",
                  )     )
              rename_keys.append(
                  (f"""{old}/encoder/layer_._{i}/output/dense/kernel:0""", f"""{new}.encoder.layer.{i}.output.dense.weight""")     )
              rename_keys.append(
                  (f"""{old}/encoder/layer_._{i}/output/dense/bias:0""", f"""{new}.encoder.layer.{i}.output.dense.bias""")     )
              rename_keys.append(
                  (f"""{old}/encoder/layer_._{i}/output/LayerNorm/gamma:0""", f"""{new}.encoder.layer.{i}.output.LayerNorm.weight""")     )
              rename_keys.append(
                  (f"""{old}/encoder/layer_._{i}/output/LayerNorm/beta:0""", f"""{new}.encoder.layer.{i}.output.LayerNorm.bias""")     )
  
        rename_keys.append((f"""{old}/embeddings/word_embeddings/weight:0""", f"""{new}.embeddings.word_embeddings.weight""")     )
        rename_keys.append(
            (f"""{old}/embeddings/position_embeddings/embeddings:0""", f"""{new}.embeddings.position_embeddings.weight""")     )
        rename_keys.append(
            (f"""{old}/embeddings/token_type_embeddings/embeddings:0""", f"""{new}.embeddings.token_type_embeddings.weight""")     )
        rename_keys.append((f"""{old}/embeddings/LayerNorm/gamma:0""", f"""{new}.embeddings.LayerNorm.weight""")     )
        rename_keys.append((f"""{old}/embeddings/LayerNorm/beta:0""", f"""{new}.embeddings.LayerNorm.bias""")     )
  
        rename_keys.append((f"""{old}/pooler/dense/kernel:0""", f"""{new}.pooler.dense.weight""")     )
        rename_keys.append((f"""{old}/pooler/dense/bias:0""", f"""{new}.pooler.dense.bias""")     )
        rename_keys.append(('''dense/kernel:0''', '''text_projection.weight''')     )
        rename_keys.append(('''dense/bias:0''', '''text_projection.bias''')     )
        rename_keys.append(('''dense/bias:0''', '''text_projection.bias''')     )
        rename_keys.append(('''temperature:0''', '''temperature''')     )
  
        for item in rename_keys:
              if item[0] in original_param_names:
                    lowercase			:   Tuple					   =		item[1]
        return key_mapping
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->Any:
  
  
  
  
  
  
  
        """simple docstring"""
  
        list(hf_params.keys()     )
  
        for key, value in tf_params.items():
              if key not in key_mapping:
                    continue
  
              lowercase			:   List[str]					   =		key_mapping[key]
              if "_conv" in key and "kernel" in key:
                    lowercase			:   List[Any]					   =		torch.from_numpy(_UpperCamelCase     ).permute(3,    2,    0,    1     )
              elif "embeddings" in key:
                    lowercase			:   int					   =		torch.from_numpy(_UpperCamelCase     )
              elif "depthwise_kernel" in key:
                    lowercase			:   Union[str, Any]					   =		torch.from_numpy(_UpperCamelCase     ).permute(2,    3,    0,    1     )
              elif "kernel" in key:
                    lowercase			:   int					   =		torch.from_numpy(np.transpose(_UpperCamelCase     )     )
              elif "temperature" in key:
                    lowercase			:   Optional[int]					   =		value
              elif "bn/gamma" or "bn/beta" in key:
                    lowercase			:   Dict					   =		torch.from_numpy(np.transpose(_UpperCamelCase     )     ).squeeze()
              else:
                    lowercase			:   Union[str, Any]					   =		torch.from_numpy(_UpperCamelCase     )
  
              # Replace HF parameters with original TF model parameters
              hf_params[hf_key].copy_(_UpperCamelCase     )
  
  
  
  
  @torch.no_grad()
  def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )    ->Dict:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   str					   =		64
        lowercase			:   str					   =		Tokenizer(_UpperCamelCase     )
        lowercase			:   Optional[int]					   =		align.Align('''efficientnet-b7''',    '''bert-base''',    640,    _UpperCamelCase,    tok.get_vocab_size()     )
        original_model.compile()
        original_model.load_weights(_UpperCamelCase     )
  
        lowercase			:   Optional[Any]					   =		original_model.trainable_variables
        lowercase			:   Tuple					   =		original_model.non_trainable_variables
        lowercase			:   Optional[int]					   =		{param.name: param.numpy() for param in tf_params}
        for param in tf_non_train_params:
              lowercase			:   List[str]					   =		param.numpy()
        lowercase			:   str					   =		list(tf_params.keys()     )
  
        # Load HuggingFace model
        lowercase			:   Tuple					   =		get_align_config()
        lowercase			:   List[Any]					   =		AlignModel(_UpperCamelCase     ).eval()
        lowercase			:   Union[str, Any]					   =		hf_model.state_dict()
  
        # Create src-to-dst parameter name mapping dictionary
        print('''Converting parameters...'''     )
        lowercase			:   List[str]					   =		rename_keys(_UpperCamelCase     )
        replace_params(_UpperCamelCase,    _UpperCamelCase,    _UpperCamelCase     )
  
        # Initialize processor
        lowercase			:   Union[str, Any]					   =		get_processor()
        lowercase			:   Optional[Any]					   =		processor(
            images=prepare_img(),    text='''A picture of a cat''',    padding='''max_length''',    max_length=64,    return_tensors='''pt'''     )
  
        # HF model inference
        hf_model.eval()
        with torch.no_grad():
              lowercase			:   Dict					   =		hf_model(**_UpperCamelCase     )
  
        lowercase			:   int					   =		outputs.image_embeds.detach().numpy()
        lowercase			:   Any					   =		outputs.text_embeds.detach().numpy()
  
        # Original model inference
        lowercase			:   Any					   =		False
        lowercase			:   Tuple					   =		EfficientNetImageProcessor(
            do_center_crop=_UpperCamelCase,    do_rescale=_UpperCamelCase,    do_normalize=_UpperCamelCase,    include_top=_UpperCamelCase,    resample=Image.BILINEAR,    )
        lowercase			:   str					   =		tf_image_processor(images=prepare_img(),    return_tensors='''tf''',    data_format='''channels_last'''     )['''pixel_values''']
        lowercase			:   int					   =		tok(tf.constant(['''A picture of a cat''']     )     )
  
        lowercase			:   Optional[int]					   =		original_model.image_encoder(_UpperCamelCase,    training=_UpperCamelCase     )
        lowercase			:   Optional[int]					   =		original_model.text_encoder(_UpperCamelCase,    training=_UpperCamelCase     )
  
        lowercase			:   Union[str, Any]					   =		tf.nn.la_normalize(_UpperCamelCase,    axis=-1     )
        lowercase			:   List[str]					   =		tf.nn.la_normalize(_UpperCamelCase,    axis=-1     )
  
        # Check whether original and HF model outputs match  -> np.allclose
        if not np.allclose(_UpperCamelCase,    _UpperCamelCase,    atol=1e-3     ):
              raise ValueError('''The predicted image features are not the same.'''     )
        if not np.allclose(_UpperCamelCase,    _UpperCamelCase,    atol=1e-3     ):
              raise ValueError('''The predicted text features are not the same.'''     )
        print('''Model outputs match!'''     )
  
        if save_model:
              # Create folder to save model
              if not os.path.isdir(_UpperCamelCase     ):
                    os.mkdir(_UpperCamelCase     )
              # Save converted model and image processor
              hf_model.save_pretrained(_UpperCamelCase     )
              processor.save_pretrained(_UpperCamelCase     )
  
        if push_to_hub:
              # Push model and image processor to hub
              print('''Pushing converted ALIGN to the hub...'''     )
              processor.push_to_hub('''align-base'''     )
              hf_model.push_to_hub('''align-base'''     )
  
  
  if __name__ == "__main__":
    __a   				=      argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '''--checkpoint_path''',
        default='''./weights/model-weights''',
        type=str,
        help='''Path to the pretrained TF ALIGN checkpoint.''',
    )
    parser.add_argument(
        '''--pytorch_dump_folder_path''',
        default='''hf_model''',
        type=str,
        help='''Path to the output PyTorch model directory.''',
    )
    parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
    parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')
  
    __a   				=      parser.parse_args()
    convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
  
  