code: 
  
  """simple docstring"""
  
  
  
  
  
  
  
  import argparse
  
  import torch
  
  from transformers import ChineseCLIPConfig, ChineseCLIPModel
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a	,   a	,   a					=pt_weights[f'''{prefix}.in_proj_weight'''].chunk(3 ,					dim=0	)
      a	,   a	,   a					=pt_weights[f'''{prefix}.in_proj_bias'''].chunk(3 ,					dim=0	)
  
      a					=pt_weights[f'''{prefix}.out_proj.weight''']
      a					=pt_weights[f'''{prefix}.out_proj.bias''']
  
      a					=q_proj
      a					=q_proj_bias
  
      a					=k_proj
      a					=k_proj_bias
  
      a					=v_proj
      a					=v_proj_bias
  
      a					=out_proj_weights
      a					=out_proj_bias
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      copy_linear(hf_mlp.fca ,					lowercase ,					f'''{prefix}.c_fc'''	)
      copy_linear(hf_mlp.fca ,					lowercase ,					f'''{prefix}.c_proj'''	)
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=pt_weights[f'''{prefix}.weight'''].data
      a					=pt_weights[f'''{prefix}.bias'''].data
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      copy_linear(hf_layer.layer_norma ,					lowercase ,					f'''{prefix}.ln_1'''	)
      copy_linear(hf_layer.layer_norma ,					lowercase ,					f'''{prefix}.ln_2'''	)
  
      # copy MLP
      copy_mlp(hf_layer.mlp ,					lowercase ,					f'''{prefix}.mlp'''	)
  
      # copy attn
      copy_attn_layer(hf_layer.self_attn ,					lowercase ,					f'''{prefix}.attn'''	)
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      for layer_id, hf_layer in enumerate(lowercase	):
          copy_layer(lowercase ,					lowercase ,					f'''{prefix}.{layer_id}'''	)
  def _A		(		lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=pt_weights['''text_projection'''].data.T
  
      # copy text encoder
      for name, param in hf_model.text_model.named_parameters():
          a					=pt_weights[f'''bert.{name}'''].data
  def _A		(		lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=pt_weights['''visual.proj'''].data.T
  
      # copy layer norms
      copy_linear(hf_model.vision_model.pre_layrnorm ,					lowercase ,					'''visual.ln_pre'''	)
      copy_linear(hf_model.vision_model.post_layernorm ,					lowercase ,					'''visual.ln_post'''	)
  
      # copy embeddings
      a					=pt_weights['''visual.conv1.weight'''].data
      a					=pt_weights['''visual.class_embedding'''].data
      a					=pt_weights['''visual.positional_embedding'''].data
  
      # copy encoder
      copy_layers(hf_model.vision_model.encoder.layers ,					lowercase ,					'''visual.transformer.resblocks'''	)
  @torch.no_grad()
  def _A		(		lowercase ,					lowercase ,					lowercase=None	):
  
  
  
  
  
  
  
      """simple docstring"""
      assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
      a					=ChineseCLIPConfig.from_pretrained(lowercase	)
  
      a					=ChineseCLIPModel(lowercase	).eval()
  
      a					=torch.load(lowercase ,					map_location='''cpu'''	)['''state_dict''']
      a					={(name[7:] if name.startswith('''module.'''	) else name): value for name, value in pt_weights.items()}
  
      copy_text_model_and_projection(lowercase ,					lowercase	)
      copy_vision_model_and_projection(lowercase ,					lowercase	)
      a					=pt_weights['''logit_scale'''].data
  
      hf_model.save_pretrained(lowercase	)
  
  
  if __name__ == "__main__":
         lowerCamelCase_     :     Tuple    		=						argparse.ArgumentParser()
         parser.add_argument(
             """--pytorch_dump_folder_path""",
             default=None,
             type=str,
             help="""Path to the output folder storing converted hf PyTorch model.""",
         )
         parser.add_argument(
             """--checkpoint_path""", default=None, type=str, help="""Path to original github format ChineseCLIP checkpoint."""
         )
         parser.add_argument(
             """--config_path""", default=None, required=True, type=str, help="""Path to hf config.json of model to convert."""
         )
         lowerCamelCase_     :     Optional[Any]    		=						parser.parse_args()
  
         convert_chinese_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
         print("""The conversion is finished!""")
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  import argparse
  
  from tax import checkpoints
  
  from transformers import FlaxTaForConditionalGeneration, TaConfig
  def _A		(		lowercase ,					lowercase ,					lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=TaConfig.from_pretrained(lowercase	)
      a					=FlaxTaForConditionalGeneration(config=lowercase	)
      a					=checkpoints.load_tax_checkpoint(lowercase	)
  
      a					='''wi_0''' in tax_model['''target''']['''encoder''']['''layers_0''']['''mlp''']
  
      # Encoder
      for layer_index in range(config.num_layers	):
          a					=f'''layers_{str(lowercase	)}'''
  
          # Self-Attention
          a					=tax_model['''target''']['''encoder'''][layer_name]['''attention''']['''key''']['''kernel''']
          a					=tax_model['''target''']['''encoder'''][layer_name]['''attention''']['''out''']['''kernel''']
          a					=tax_model['''target''']['''encoder'''][layer_name]['''attention''']['''query''']['''kernel''']
          a					=tax_model['''target''']['''encoder'''][layer_name]['''attention''']['''value''']['''kernel''']
  
          # Layer Normalization
          a					=tax_model['''target''']['''encoder'''][layer_name]['''pre_attention_layer_norm''']['''scale''']
  
          if split_mlp_wi:
              a					=tax_model['''target''']['''encoder'''][layer_name]['''mlp''']['''wi_0''']['''kernel''']
              a					=tax_model['''target''']['''encoder'''][layer_name]['''mlp''']['''wi_1''']['''kernel''']
          else:
              a					=tax_model['''target''']['''encoder'''][layer_name]['''mlp''']['''wi''']['''kernel''']
  
          a					=tax_model['''target''']['''encoder'''][layer_name]['''mlp''']['''wo''']['''kernel''']
  
          # Layer Normalization
          a					=tax_model['''target''']['''encoder'''][layer_name]['''pre_mlp_layer_norm''']['''scale''']
  
          # Assigning
          a					=tax_attention_key
          a					=tax_attention_out
          a					=tax_attention_query
          a					=tax_attention_value
  
          a					=tax_attention_layer_norm
  
          if split_mlp_wi:
              a					=tax_mlp_wi_a
              a					=tax_mlp_wi_a
          else:
              a					=tax_mlp_wi
  
          a					=tax_mlp_wo
          a					=tax_mlp_layer_norm
  
      # Only for layer 0:
      a					=tax_model['''target''']['''encoder''']['''relpos_bias''']['''rel_embedding'''].T
      a					=tax_encoder_rel_embedding
  
      # Assigning
      a					=tax_model['''target''']['''encoder''']['''encoder_norm''']['''scale''']
      a					=tax_encoder_norm
  
      # Decoder
      for layer_index in range(config.num_decoder_layers	):
          a					=f'''layers_{str(lowercase	)}'''
  
          # Self-Attention
          a					=tax_model['''target''']['''decoder'''][layer_name]['''self_attention''']['''key''']['''kernel''']
          a					=tax_model['''target''']['''decoder'''][layer_name]['''self_attention''']['''out''']['''kernel''']
          a					=tax_model['''target''']['''decoder'''][layer_name]['''self_attention''']['''query''']['''kernel''']
          a					=tax_model['''target''']['''decoder'''][layer_name]['''self_attention''']['''value''']['''kernel''']
  
          # Layer Normalization
          a					=tax_model['''target''']['''decoder'''][layer_name]['''pre_self_attention_layer_norm'''][
              '''scale'''
          ]
  
          # Encoder-Decoder-Attention
          a					=tax_model['''target''']['''decoder'''][layer_name]['''encoder_decoder_attention''']['''key'''][
              '''kernel'''
          ]
          a					=tax_model['''target''']['''decoder'''][layer_name]['''encoder_decoder_attention''']['''out'''][
              '''kernel'''
          ]
          a					=tax_model['''target''']['''decoder'''][layer_name]['''encoder_decoder_attention''']['''query'''][
              '''kernel'''
          ]
          a					=tax_model['''target''']['''decoder'''][layer_name]['''encoder_decoder_attention''']['''value'''][
              '''kernel'''
          ]
  
          # Layer Normalization
          a					=tax_model['''target''']['''decoder'''][layer_name]['''pre_cross_attention_layer_norm''']['''scale''']
  
          # MLP
          if split_mlp_wi:
              a					=tax_model['''target''']['''decoder'''][layer_name]['''mlp''']['''wi_0''']['''kernel''']
              a					=tax_model['''target''']['''decoder'''][layer_name]['''mlp''']['''wi_1''']['''kernel''']
          else:
              a					=tax_model['''target''']['''decoder'''][layer_name]['''mlp''']['''wi''']['''kernel''']
  
          a					=tax_model['''target''']['''decoder'''][layer_name]['''mlp''']['''wo''']['''kernel''']
  
          # Layer Normalization
          a					=tax_model['''target''']['''decoder'''][layer_name]['''pre_mlp_layer_norm''']['''scale''']
  
          # Assigning
          a					=tax_attention_key
          a					=tax_attention_out
          a					=tax_attention_query
          a					=tax_attention_value
  
          a					=tax_pre_attention_layer_norm
  
          a					=tax_enc_dec_attention_key
          a					=tax_enc_dec_attention_out
          a					=tax_enc_dec_attention_query
          a					=tax_enc_dec_attention_value
  
          a					=tax_cross_layer_norm
  
          if split_mlp_wi:
              a					=tax_mlp_wi_a
              a					=tax_mlp_wi_a
          else:
              a					=tax_mlp_wi
  
          a					=tax_mlp_wo
  
          a					=txa_mlp_layer_norm
  
      # Decoder Normalization
      a					=tax_model['''target''']['''decoder''']['''decoder_norm''']['''scale''']
      a					=txa_decoder_norm
  
      # Only for layer 0:
      a					=tax_model['''target''']['''decoder''']['''relpos_bias''']['''rel_embedding'''].T
      a					=tax_decoder_rel_embedding
  
      # Token Embeddings
      a					=tax_model['''target''']['''token_embedder''']['''embedding''']
      a					=txa_token_embeddings
  
      # LM Head (only in v1.1 checkpoints)
      if "logits_dense" in tax_model["target"]["decoder"]:
          a					=tax_model['''target''']['''decoder''']['''logits_dense''']['''kernel''']
  
      flax_model.save_pretrained(lowercase	)
      print('''T5X Model was sucessfully converted!'''	)
  
  
  if __name__ == "__main__":
         lowerCamelCase_     :     Dict    		=						argparse.ArgumentParser()
         # Required parameters
         parser.add_argument(
             """--t5x_checkpoint_path""", default=None, type=str, required=True, help="""Path the TX5 checkpoint."""
         )
         parser.add_argument("""--config_name""", default=None, type=str, required=True, help="""Config name of T5 model.""")
         parser.add_argument(
             """--flax_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output FLAX model."""
         )
         lowerCamelCase_     :     Optional[int]    		=						parser.parse_args()
         convert_tax_checkpoint_to_flax(args.tax_checkpoint_path, args.config_name, args.flax_dump_folder_path)