

import unittest

from cer import CER


__A    	=			CER()



class 						lowercase_					(						unittest.TestCase  ):



      def 		UpperCamelCase_	(    self   :       Any	)					->  Union[str, Any]:
        _snake_case		=							['''White House''']
        _snake_case		=							['''white house''']
        # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.18_1818_1818	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       Union[str, Any]	)					->  Dict:
        _snake_case		=							['''were wolf''']
        _snake_case		=							['''werewolf''']
        # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.111_1111	) < 1e-6	)

        _snake_case		=							['''werewolf''']
        _snake_case		=							['''weae     wolf''']
        # S = 1, D = 1, I = 0, N = 8, CER = 0.25
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.25	) < 1e-6	)

        # consecutive whitespaces case 1
        _snake_case		=							['''were wolf''']
        _snake_case		=							['''were               wolf''']
        # S = 0, D = 0, I = 0, N = 9, CER = 0
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.0	) < 1e-6	)

        # consecutive whitespaces case 2
        _snake_case		=							['''were   wolf''']
        _snake_case		=							['''were               wolf''']
        # S = 0, D = 0, I = 0, N = 9, CER = 0
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.0	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       int	)					->  Tuple:
        _snake_case		=							['''werewolf''']
        _snake_case		=							['''weaewolf''']
        # S = 1, D = 0, I = 0, N = 8, CER = 0.125
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.125	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       Optional[Any]	)					->  Optional[Any]:
        _snake_case		=							['''werewolf''']
        _snake_case		=							['''wereawolf''']
        # S = 0, D = 1, I = 0, N = 8, CER = 0.125
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.125	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       Tuple	)					->  Tuple:
        _snake_case		=							['''werewolf''']
        _snake_case		=							['''wereolf''']
        # S = 0, D = 0, I = 1, N = 8, CER = 0.125
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.125	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       List[str]	)					->  Any:
        _snake_case		=							['''werewolf''']
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertEqual(A__    ,      0.0	)



      def 		UpperCamelCase_	(    self   :       str	)					->  Optional[Any]:
        _snake_case		=							['''werewolf''', '''I am your father''']
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertEqual(A__    ,      0.0	)

        _snake_case		=							['''werewolf''', '''I am your father''', '''doge''']
        _snake_case		=							['''werxwolf''', '''I       am your father''', '''doge''']
        # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.0357_1428	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       Tuple	)					->  Union[str, Any]:
        _snake_case		=							['''My hovercraft''', '''is full of eels''']
        _snake_case		=							['''My hovercraft is full''', ''' of eels''']
        # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
        # whitespace at the front of " of eels" will be strip during preporcessing
        # so need to insert 2 whitespaces
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__    ,      concatenate_texts=A__	)
        self.assertTrue(abs(char_error_rate - 0.07_1428	) < 1e-6	)



      def 		UpperCamelCase_	(    self   :       Optional[Any]	)					->  Tuple:
        _snake_case		=							['''我能吞下玻璃而不伤身体''']
        _snake_case		=							[''' 能吞虾玻璃而 不霜身体啦''']
        # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.45_4545_4545	) < 1e-6	)

        _snake_case		=							['''我能吞下玻璃''', '''而不伤身体''']
        _snake_case		=							['''我    能 吞 下 玻 璃''', '''而不伤身体''']
        # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertTrue(abs(char_error_rate - 0.4545_4545_4545	) < 1e-6	)

        _snake_case		=							['''我能吞下玻璃而不伤身体''']
        _snake_case		=							cer.compute(predictions=A__    ,      references=A__	)
        self.assertFalse(A__    ,      0.0	)







      def 		UpperCamelCase_	(    self   :       Any	)					->  Dict:
        _snake_case		=							['''''']
        _snake_case		=							['''Hypothesis''']
        with self.assertRaises(A__	):
          cer.compute(predictions=A__    ,      references=A__	)


if __name__ == "__main__":
 unittest.main()




import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			Optional[Any]:



  """simple docstring"""






  _snake_case,  _snake_case,  _snake_case		=							pt_attn_layer.in_proj_weight.chunk(3				, dim=0  )
  _snake_case,  _snake_case,  _snake_case		=							pt_attn_layer.in_proj_bias.chunk(3				, dim=0  )

  _snake_case		=							pt_attn_layer.out_proj.weight
  _snake_case		=							pt_attn_layer.out_proj.bias

  _snake_case		=							q_proj
  _snake_case		=							q_proj_bias

  _snake_case		=							k_proj
  _snake_case		=							k_proj_bias

  _snake_case		=							v_proj
  _snake_case		=							v_proj_bias

  _snake_case		=							out_proj_weights
  _snake_case		=							out_proj_bias



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			List[str]:



  """simple docstring"""






  copy_linear(hf_mlp.fca				, pt_mlp.c_fc  )
  copy_linear(hf_mlp.fca				, pt_mlp.c_proj  )



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			str:



  """simple docstring"""






  _snake_case		=							pt_linear.weight
  _snake_case		=							pt_linear.bias



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			Tuple:



  """simple docstring"""






  copy_linear(hf_layer.layer_norma				, pt_layer.ln_a  )
  copy_linear(hf_layer.layer_norma				, pt_layer.ln_a  )

  # copy MLP
  copy_mlp(hf_layer.mlp				, pt_layer.mlp  )

  # copy attn
  copy_attn_layer(hf_layer.self_attn				, pt_layer.attn  )



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			List[Any]:



  """simple docstring"""






  for hf_layer, pt_layer in zip(_UpperCamelCase				, _UpperCamelCase  ):
    copy_layer(_UpperCamelCase				, _UpperCamelCase  )



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			List[Any]:



  """simple docstring"""






  _snake_case		=							pt_model.token_embedding.weight
  _snake_case		=							pt_model.positional_embedding

  # copy layer norm
  copy_linear(hf_encoder.final_layer_norm				, pt_model.ln_final  )

  # copy hidden layers
  copy_layers(hf_encoder.encoder.layers				, pt_model.transformer.resblocks  )



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			Tuple:



  """simple docstring"""






  _snake_case		=							pt_model.text_projection.data.T

  # copy text encoder
  copy_encoder(hf_model.text_model				, _UpperCamelCase  )



def    snake_case_(_UpperCamelCase				, _UpperCamelCase  )							->			int:



  """simple docstring"""






  _snake_case		=							pt_model.visual.proj.data.T

  # copy layer norms
  copy_linear(hf_model.vision_model.pre_layrnorm				, pt_model.visual.ln_pre  )
  copy_linear(hf_model.vision_model.post_layernorm				, pt_model.visual.ln_post  )

  # copy embeds
  _snake_case		=							pt_model.visual.conva.weight.data
  _snake_case		=							pt_model.visual.class_embedding
  _snake_case		=							pt_model.visual.positional_embedding.data

  # copy encoder
  copy_layers(hf_model.vision_model.encoder.layers				, pt_model.visual.transformer.resblocks  )



@torch.no_grad()
def    snake_case_(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase=None  )							->			Any:



  """simple docstring"""






  if config_path is not None:
    _snake_case		=							CLIPConfig.from_pretrained(_UpperCamelCase  )
  else:
    _snake_case		=							CLIPConfig(projection_dim=512				, text_config={}				, vision_config={}  )

  _snake_case		=							CLIPModel(_UpperCamelCase  ).eval()

  _snake_case,  _snake_case		=							load(_UpperCamelCase				, device='''cpu'''				, jit=_UpperCamelCase  )
  _snake_case		=							pt_model.eval()

  copy_text_model_and_projection(_UpperCamelCase				, _UpperCamelCase  )
  copy_vison_model_and_projection(_UpperCamelCase				, _UpperCamelCase  )
  _snake_case		=							pt_model.logit_scale

  _snake_case		=							torch.arange(0				, 77  ).unsqueeze(0  )
  _snake_case		=							torch.randn(1				, 3				, 224				, 224  )

  _snake_case		=							hf_model(input_ids=_UpperCamelCase				, pixel_values=_UpperCamelCase				, return_dict=_UpperCamelCase  )
  _snake_case		=							hf_outputs.logits_per_image
  _snake_case		=							hf_outputs.logits_per_text
  _snake_case,  _snake_case		=							pt_model(_UpperCamelCase				, _UpperCamelCase  )

  assert torch.allclose(_UpperCamelCase				, _UpperCamelCase				, atol=1E-3  )
  assert torch.allclose(_UpperCamelCase				, _UpperCamelCase				, atol=1E-3  )

  hf_model.save_pretrained(_UpperCamelCase  )


if __name__ == "__main__":
 __A    	=			argparse.ArgumentParser()
 parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
 parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''')
 parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
 __A    	=			parser.parse_args()

 convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)

