code: 
  
  
  
  
  
  
  import unittest
  
  import torch
  
  from diffusers import UNetaDModel
  from diffusers.utils import floats_tensor, slow, torch_device
  
  from .test_modeling_common import ModelTesterMixin, UNetTesterMixin
  
  
  
  class 							_A (    UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       str   =   UNetaDModel
      lowerCamelCase  :       List[Any]   =   'sample'
  
  
  
      @property
      def _a       (							self			:    int			)			->       int:
             __UpperCAmelCase    							=4
             __UpperCAmelCase    							=14
             __UpperCAmelCase    							=16
  
             __UpperCAmelCase    							=floats_tensor((batch_size, num_features, seq_len)			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([10] * batch_size			).to(__SCREAMING_SNAKE_CASE			)
  
             return {"sample": noise, "timestep": time_step}
  
  
  
      @property
      def _a       (							self			:    int			)			->       str:
             return (4, 14, 16)
  
  
  
      @property
      def _a       (							self			:    Union[str, Any]			)			->       int:
             return (4, 14, 16)
  
  
  
      def _a       (							self			:    Dict			)			->       Optional[Any]:
             pass
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       Optional[Any]:
             pass
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[Any]			)			->       int:
             super().test_determinism()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    int			)			->       Optional[Any]:
             super().test_outputs_equivalence()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[Any]			)			->       Optional[int]:
             super().test_from_save_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    str			)			->       Optional[int]:
             super().test_from_save_pretrained_variant()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Any			)			->       Dict:
             super().test_model_from_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Any			)			->       List[str]:
             super().test_output()
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       Optional[int]:
             __UpperCAmelCase    							={
                 """block_out_channels""": (32, 64, 128, 256),
                 """in_channels""": 14,
                 """out_channels""": 14,
                 """time_embedding_type""": """positional""",
                 """use_timestep_embedding""": True,
                 """flip_sin_to_cos""": False,
                 """freq_shift""": 1.0,
                 """out_block_type""": """OutConv1DBlock""",
                 """mid_block_type""": """MidResTemporalBlock1D""",
                 """down_block_types""": ("""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""),
                 """up_block_types""": ("""UpResnetBlock1D""", """UpResnetBlock1D""", """UpResnetBlock1D"""),
                 """act_fn""": """mish""",
             }
             __UpperCAmelCase    							=self.dummy_input
             return init_dict, inputs_dict
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Tuple			)			->       Any:
             __UpperCAmelCase							,   __UpperCAmelCase    							=UNetaDModel.from_pretrained(
                 """bglick13/hopper-medium-v2-value-function-hor32"""   ,    output_loading_info=__SCREAMING_SNAKE_CASE   ,    subfolder="""unet"""			)
             self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
             self.assertEqual(len(loading_info["""missing_keys"""]			)   ,    0			)
  
             model.to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=model(**self.dummy_input			)
  
             assert image is not None, "Make sure output is not None"
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    str			)			->       Union[str, Any]:
             __UpperCAmelCase    							=UNetaDModel.from_pretrained("""bglick13/hopper-medium-v2-value-function-hor32"""   ,    subfolder="""unet"""			)
             torch.manual_seed(0			)
             if torch.cuda.is_available():
                    torch.cuda.manual_seed_all(0			)
  
             __UpperCAmelCase    							=model.config.in_channels
             __UpperCAmelCase    							=16
             __UpperCAmelCase    							=torch.randn((1, seq_len, num_features)			).permute(
                 0   ,    2   ,    1			)  # match original, we can update values and remove
             __UpperCAmelCase    							=torch.full((num_features,)   ,    0			)
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).sample.permute(0   ,    2   ,    1			)
  
             __UpperCAmelCase    							=output[0, -3:, -3:].flatten()
             # fmt: off
             __UpperCAmelCase    							=torch.tensor([-2.137_172, 1.1_426_016, 0.3_688_687, -0.766_922, 0.7_303_146, 0.11_038_864, -0.4_760_633, 0.13_270_172, 0.02_591_348]			)
             # fmt: on
             self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    rtol=1e-3			)			)
  
  
  
      def _a       (							self			:    List[Any]			)			->       List[str]:
             # Not implemented yet for this UNet
             pass
  
  
  
      @slow
      def _a       (							self			:    str			)			->       int:
             __UpperCAmelCase    							="""harmonai/maestro-150k"""
             __UpperCAmelCase    							=UNetaDModel.from_pretrained(__SCREAMING_SNAKE_CASE   ,    subfolder="""unet"""			)
             model.to(__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=65536
             __UpperCAmelCase    							=torch.sin(torch.arange(__SCREAMING_SNAKE_CASE			)[None, None, :].repeat(1   ,    2   ,    1			)			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([1]			).to(__SCREAMING_SNAKE_CASE			)
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).sample
  
             __UpperCAmelCase    							=output.abs().sum()
             __UpperCAmelCase    							=output.abs().max()
  
             assert (output_sum - 224.0_896).abs() < 0.5
             assert (output_max - 0.0_607).abs() < 4e-4
  
  
  
  
  class 							_A (    UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       Optional[Any]   =   UNetaDModel
      lowerCamelCase  :       str   =   'sample'
  
  
  
      @property
      def _a       (							self			:    Optional[Any]			)			->       Optional[Any]:
             __UpperCAmelCase    							=4
             __UpperCAmelCase    							=14
             __UpperCAmelCase    							=16
  
             __UpperCAmelCase    							=floats_tensor((batch_size, num_features, seq_len)			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([10] * batch_size			).to(__SCREAMING_SNAKE_CASE			)
  
             return {"sample": noise, "timestep": time_step}
  
  
  
      @property
      def _a       (							self			:    Tuple			)			->       List[Any]:
             return (4, 14, 16)
  
  
  
      @property
      def _a       (							self			:    Optional[Any]			)			->       Union[str, Any]:
             return (4, 14, 1)
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    List[str]			)			->       Optional[int]:
             super().test_determinism()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[int]			)			->       Union[str, Any]:
             super().test_outputs_equivalence()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[Any]			)			->       Dict:
             super().test_from_save_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    List[str]			)			->       str:
             super().test_from_save_pretrained_variant()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[int]			)			->       Any:
             super().test_model_from_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    int			)			->       Optional[Any]:
             # UNetRL is a value-function is different output shape
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.prepare_init_args_and_inputs_for_common()
             __UpperCAmelCase    							=self.model_class(**__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(**__SCREAMING_SNAKE_CASE			)
  
                    if isinstance(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			):
                           __UpperCAmelCase    							=output.sample
  
             self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.Size((inputs_dict["""sample"""].shape[0], 1)			)
             self.assertEqual(output.shape   ,    __SCREAMING_SNAKE_CASE   ,    """Input and output shapes do not match"""			)
  
  
  
      def _a       (							self			:    Tuple			)			->       Any:
             pass
  
  
  
      def _a       (							self			:    str			)			->       Union[str, Any]:
             pass
  
  
  
      def _a       (							self			:    Dict			)			->       str:
             __UpperCAmelCase    							={
                 """in_channels""": 14,
                 """out_channels""": 14,
                 """down_block_types""": ["""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""],
                 """up_block_types""": [],
                 """out_block_type""": """ValueFunction""",
                 """mid_block_type""": """ValueFunctionMidBlock1D""",
                 """block_out_channels""": [32, 64, 128, 256],
                 """layers_per_block""": 1,
                 """downsample_each_block""": True,
                 """use_timestep_embedding""": True,
                 """freq_shift""": 1.0,
                 """flip_sin_to_cos""": False,
                 """time_embedding_type""": """positional""",
                 """act_fn""": """mish""",
             }
             __UpperCAmelCase    							=self.dummy_input
             return init_dict, inputs_dict
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Tuple			)			->       List[Any]:
             __UpperCAmelCase							,   __UpperCAmelCase    							=UNetaDModel.from_pretrained(
                 """bglick13/hopper-medium-v2-value-function-hor32"""   ,    output_loading_info=__SCREAMING_SNAKE_CASE   ,    subfolder="""value_function"""			)
             self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
             self.assertEqual(len(vf_loading_info["""missing_keys"""]			)   ,    0			)
  
             value_function.to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=value_function(**self.dummy_input			)
  
             assert image is not None, "Make sure output is not None"
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    List[Any]			)			->       int:
             __UpperCAmelCase							,   __UpperCAmelCase    							=UNetaDModel.from_pretrained(
                 """bglick13/hopper-medium-v2-value-function-hor32"""   ,    output_loading_info=__SCREAMING_SNAKE_CASE   ,    subfolder="""value_function"""			)
             torch.manual_seed(0			)
             if torch.cuda.is_available():
                    torch.cuda.manual_seed_all(0			)
  
             __UpperCAmelCase    							=value_function.config.in_channels
             __UpperCAmelCase    							=14
             __UpperCAmelCase    							=torch.randn((1, seq_len, num_features)			).permute(
                 0   ,    2   ,    1			)  # match original, we can update values and remove
             __UpperCAmelCase    							=torch.full((num_features,)   ,    0			)
  
             with torch.no_grad():
                    __UpperCAmelCase    							=value_function(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).sample
  
             # fmt: off
             __UpperCAmelCase    							=torch.tensor([165.25] * seq_len			)
             # fmt: on
             self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    rtol=1e-3			)			)
  
  
  
      def _a       (							self			:    Dict			)			->       Optional[int]:
             # Not implemented yet for this UNet
             pass
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import argparse
  import os
  import pathlib
  
  import fairseq
  import torch
  from fairseq.modules import TransformerSentenceEncoderLayer
  from packaging import version
  
  from transformers import (
      DataaVecTextConfig,
      DataaVecTextForMaskedLM,
      DataaVecTextForSequenceClassification,
      DataaVecTextModel,
  )
  from transformers.models.bert.modeling_bert import (
      BertIntermediate,
      BertLayer,
      BertOutput,
      BertSelfAttention,
      BertSelfOutput,
  )
  
  # IMPORTANT: In order for this script to run, please make sure to download the dictionary: `dict.txt` from wget https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz
  # File copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_text.py
  from transformers.utils import logging
  
  
  if version.parse(fairseq.__version__) < version.parse("0.9.0"):
     raise Exception("requires fairseq >= 0.9.0")
  
  
  logging.set_verbosity_info()
  __A  							=  logging.get_logger(__name__)
  
  __A  							=  "Hello world! cécé herlolip"
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	str     ,			A_:	str     ,			A_:	bool		)  ->							str:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase							,   __UpperCAmelCase    							=os.path.split(A_		)
         __UpperCAmelCase    							=DataaVecTextModel.from_pretrained(
             A_     ,			checkpoint_file=A_		)
         dataavec.eval()  # disable dropout
         __UpperCAmelCase    							=dataavec.models[0]
         __UpperCAmelCase    							=dataavec_model.encoder.sentence_encoder
         __UpperCAmelCase    							=DataaVecTextConfig(
             vocab_size=dataavec_sent_encoder.embed_tokens.num_embeddings     ,			hidden_size=dataavec_model.args.encoder_embed_dim     ,			num_hidden_layers=dataavec_model.args.encoder_layers     ,			num_attention_heads=dataavec_model.args.encoder_attention_heads     ,			intermediate_size=dataavec_model.args.encoder_ffn_embed_dim     ,			max_position_embeddings=514     ,			type_vocab_size=1     ,			layer_norm_eps=1e-5     ,			)
         if classification_head:
                __UpperCAmelCase    							=dataavec.model.classification_heads["""mnli"""].out_proj.weight.shape[0]
         print("""Our BERT config:"""     ,			A_		)
  
         __UpperCAmelCase    							=DataaVecTextForSequenceClassification(A_		) if classification_head else DataaVecTextForMaskedLM(A_		)
         model.eval()
  
         # Now let's copy all the weights.
         # Embeddings
         __UpperCAmelCase    							=dataavec_sent_encoder.embed_tokens.weight
         __UpperCAmelCase    							=dataavec_sent_encoder.embed_positions.weight
         __UpperCAmelCase    							=torch.zeros_like(
             model.dataavec_text.embeddings.token_type_embeddings.weight		)  # just zero them out b/c data2vec doesn't use them.
         __UpperCAmelCase    							=dataavec_sent_encoder.layernorm_embedding.weight
         __UpperCAmelCase    							=dataavec_sent_encoder.layernorm_embedding.bias
  
         for i in range(config.num_hidden_layers		):
                # Encoder: start of layer
                __UpperCAmelCase    							=model.dataavec_text.encoder.layer[i]
                __UpperCAmelCase    							=dataavec_sent_encoder.layers[i]
  
                # self attention
                __UpperCAmelCase    							=layer.attention.self
                assert dataavec_layer.self_attn.k_proj.weight.data.shape == torch.Size(
                    (config.hidden_size, config.hidden_size)		), (
                    "Shape for data2vec_layer.self_attn.k_proj.weight.data should be"
                    F''' {torch.Size((config.hidden_size, config.hidden_size)		)}'''
                )
                assert dataavec_layer.self_attn.q_proj.weight.data.shape == torch.Size(
                    (config.hidden_size, config.hidden_size)		), (
                    "Shape for data2vec_layer.self_attn.q_proj.weight.data should be"
                    F''' {torch.Size((config.hidden_size, config.hidden_size)		)}'''
                )
                assert dataavec_layer.self_attn.v_proj.weight.data.shape == torch.Size(
                    (config.hidden_size, config.hidden_size)		), (
                    "Shape for data2vec_layer.self_attn.v_proj.weight.data should be"
                    F''' {torch.Size((config.hidden_size, config.hidden_size)		)}'''
                )
  
                __UpperCAmelCase    							=dataavec_layer.self_attn.q_proj.weight
                __UpperCAmelCase    							=dataavec_layer.self_attn.q_proj.bias
                __UpperCAmelCase    							=dataavec_layer.self_attn.k_proj.weight
                __UpperCAmelCase    							=dataavec_layer.self_attn.k_proj.bias
                __UpperCAmelCase    							=dataavec_layer.self_attn.v_proj.weight
                __UpperCAmelCase    							=dataavec_layer.self_attn.v_proj.bias
  
                # self-attention output
                __UpperCAmelCase    							=layer.attention.output
                assert (
                    self_output.dense.weight.shape == dataavec_layer.self_attn.out_proj.weight.shape
                ), F'''Shape for self_output.dense.weight should be {dataavec_layer.self_attn.out_proj.weight.shape}'''
                __UpperCAmelCase    							=dataavec_layer.self_attn.out_proj.weight
                __UpperCAmelCase    							=dataavec_layer.self_attn.out_proj.bias
                __UpperCAmelCase    							=dataavec_layer.self_attn_layer_norm.weight
                __UpperCAmelCase    							=dataavec_layer.self_attn_layer_norm.bias
  
                # intermediate
                __UpperCAmelCase    							=layer.intermediate
                assert (
                    intermediate.dense.weight.shape == dataavec_layer.fca.weight.shape
                ), F'''Shape for intermediate.dense.weight should be {dataavec_layer.fca.weight.shape}'''
                __UpperCAmelCase    							=dataavec_layer.fca.weight
                __UpperCAmelCase    							=dataavec_layer.fca.bias
  
                # output
                __UpperCAmelCase    							=layer.output
                assert (
                    bert_output.dense.weight.shape == dataavec_layer.fca.weight.shape
                ), F'''Shape for bert_output.dense.weight should be {dataavec_layer.fca.weight.shape}'''
                __UpperCAmelCase    							=dataavec_layer.fca.weight
                __UpperCAmelCase    							=dataavec_layer.fca.bias
                __UpperCAmelCase    							=dataavec_layer.final_layer_norm.weight
                __UpperCAmelCase    							=dataavec_layer.final_layer_norm.bias
                # end of layer
  
         if classification_head:
                __UpperCAmelCase    							=dataavec.model.classification_heads["""mnli"""].dense.weight
                __UpperCAmelCase    							=dataavec.model.classification_heads["""mnli"""].dense.bias
                __UpperCAmelCase    							=dataavec.model.classification_heads["""mnli"""].out_proj.weight
                __UpperCAmelCase    							=dataavec.model.classification_heads["""mnli"""].out_proj.bias
         else:
                # LM Head
                __UpperCAmelCase    							=dataavec_model.encoder.lm_head.dense.weight
                __UpperCAmelCase    							=dataavec_model.encoder.lm_head.dense.bias
                __UpperCAmelCase    							=dataavec_model.encoder.lm_head.layer_norm.weight
                __UpperCAmelCase    							=dataavec_model.encoder.lm_head.layer_norm.bias
                __UpperCAmelCase    							=dataavec_model.encoder.lm_head.weight
                __UpperCAmelCase    							=dataavec_model.encoder.lm_head.bias
  
         # Let's check that we get the same results.
         __UpperCAmelCase    							=dataavec.encode(A_		).unsqueeze(0		)  # batch of size 1
  
         __UpperCAmelCase    							=model(A_		)[0]
         if classification_head:
                __UpperCAmelCase    							=dataavec.model.classification_heads["""mnli"""](dataavec.extract_features(A_		)		)
         else:
                __UpperCAmelCase    							=dataavec_model(A_		)[0]
         print(our_output.shape     ,			their_output.shape		)
         __UpperCAmelCase    							=torch.max(torch.abs(our_output - their_output		)		).item()
         print(F'''max_absolute_diff = {max_absolute_diff}'''		)  # ~ 1e-7
         __UpperCAmelCase    							=torch.allclose(A_     ,			A_     ,			atol=1e-3		)
         print("""Do both models output the same tensors?"""     ,			"""🔥""" if success else """💩"""		)
         if not success:
                raise Exception("""Something went wRoNg"""		)
  
         pathlib.Path(A_		).mkdir(parents=A_     ,			exist_ok=A_		)
         print(F'''Saving model to {pytorch_dump_folder_path}'''		)
         model.save_pretrained(A_		)
  
  
  if __name__ == "__main__":
     __A  							=  argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         "--checkpoint_path", default=None, type=str, required=True, help="Path the official PyTorch dump."
     )
     parser.add_argument(
         "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
     )
     parser.add_argument(
         "--classification_head", action="store_true", help="Whether to convert a final classification head."
     )
     __A  							=  parser.parse_args()
     convert_dataavec_checkpoint_to_pytorch(
         args.checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
     )
  
  
  
  
  