


import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class    UpperCAmelCase__	( unittest.TestCase		):



    """simple docstring"""






    @property
    def _a (      self   )  ->	str:
         torch.manual_seed(0   )
         __UpperCamelCase   							=UNetaDModel(
             block_out_channels=(32, 64) ,       layers_per_block=2 ,       sample_size=32 ,       in_channels=3 ,       out_channels=3 ,       down_block_types=('DownBlock2D', 'AttnDownBlock2D') ,       up_block_types=('AttnUpBlock2D', 'UpBlock2D') ,       )
         return model






    @property
    def _a (      self   )  ->	List[Any]:
         torch.manual_seed(0   )
         __UpperCamelCase   							=VQModel(
             block_out_channels=[32, 64] ,       in_channels=3 ,       out_channels=3 ,       down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] ,       up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] ,       latent_channels=3 ,       )
         return model






    @property
    def _a (      self   )  ->	Optional[int]:
         torch.manual_seed(0   )
         __UpperCamelCase   							=CLIPTextConfig(
             bos_token_id=0 ,       eos_token_id=2 ,       hidden_size=32 ,       intermediate_size=37 ,       layer_norm_eps=1E-05 ,       num_attention_heads=4 ,       num_hidden_layers=5 ,       pad_token_id=1 ,       vocab_size=1000 ,       )
         return CLIPTextModel(A_   )






    def _a (      self   )  ->	Tuple:
         __UpperCamelCase   							=self.dummy_uncond_unet
         __UpperCamelCase   							=DDIMScheduler()
         __UpperCamelCase   							=self.dummy_vq_model

         __UpperCamelCase   							=LDMPipeline(unet=A_ ,       vqvae=A_ ,       scheduler=A_   )
         ldm.to(A_   )
         ldm.set_progress_bar_config(disable=A_   )

         __UpperCamelCase   							=torch.manual_seed(0   )
         __UpperCamelCase   							=ldm(generator=A_ ,       num_inference_steps=2 ,       output_type='numpy'   ).images

         __UpperCamelCase   							=torch.manual_seed(0   )
         __UpperCamelCase   							=ldm(generator=A_ ,       num_inference_steps=2 ,       output_type='numpy' ,       return_dict=A_   )[0]

         __UpperCamelCase   							=image[0, -3:, -3:, -1]
         __UpperCamelCase   							=image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)
         __UpperCamelCase   							=np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]   )
         __UpperCamelCase   							=1E-2 if torch_device != 'mps' else 3E-2

         assert np.abs(image_slice.flatten() - expected_slice   ).max() < tolerance
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() < tolerance






@slow
@require_torch
class    UpperCAmelCase__	( unittest.TestCase		):



    """simple docstring"""






    def _a (      self   )  ->	str:
         __UpperCamelCase   							=LDMPipeline.from_pretrained('CompVis/ldm-celebahq-256'   )
         ldm.to(A_   )
         ldm.set_progress_bar_config(disable=A_   )

         __UpperCamelCase   							=torch.manual_seed(0   )
         __UpperCamelCase   							=ldm(generator=A_ ,       num_inference_steps=5 ,       output_type='numpy'   ).images

         __UpperCamelCase   							=image[0, -3:, -3:, -1]

         assert image.shape == (1, 256, 256, 3)
         __UpperCamelCase   							=np.array([0.4399, 0.4_4975, 0.4_6825, 0.474, 0.4359, 0.4581, 0.4_5095, 0.4341, 0.4447]   )
         __UpperCamelCase   							=1E-2 if torch_device != 'mps' else 3E-2

         assert np.abs(image_slice.flatten() - expected_slice   ).max() < tolerance









import argparse

import torch

from transformers import BertForMaskedLM


if __name__ == "__main__":
   _A			=						argparse.ArgumentParser(
       description=(
           'Extraction some layers of the full BertForMaskedLM or RObertaForMaskedLM for Transfer Learned'
           ' Distillation'
       )
   )
   parser.add_argument('--model_type', default='bert', choices=['bert'])
   parser.add_argument('--model_name', default='bert-base-uncased', type=str)
   parser.add_argument('--dump_checkpoint', default='serialization_dir/tf_bert-base-uncased_0247911.pth', type=str)
   parser.add_argument('--vocab_transform', action='store_true')
   _A			=						parser.parse_args()

   if args.model_type == "bert":
      _A			=						BertForMaskedLM.from_pretrained(args.model_name)
      _A			=						'bert'
   else:
      raise ValueError('args.model_type should be "bert".')

   _A			=						model.state_dict()
   _A			=						{}

   for w in ["word_embeddings", "position_embeddings"]:
      _A			=						state_dict[f"""{prefix}.embeddings.{w}.weight"""]
   for w in ["weight", "bias"]:
      _A			=						state_dict[f"""{prefix}.embeddings.LayerNorm.{w}"""]

   _A			=						0
   for teacher_idx in [0, 2, 4, 7, 9, 11]:
      for w in ["weight", "bias"]:
         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.query.{w}"""
         ]
         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.key.{w}"""
         ]
         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.value.{w}"""
         ]

         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.attention.output.dense.{w}"""
         ]
         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.attention.output.LayerNorm.{w}"""
         ]

         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.intermediate.dense.{w}"""
         ]
         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.output.dense.{w}"""
         ]
         _A			=						state_dict[
             f"""{prefix}.encoder.layer.{teacher_idx}.output.LayerNorm.{w}"""
         ]
      std_idx += 1

   _A			=						state_dict['cls.predictions.decoder.weight']
   _A			=						state_dict['cls.predictions.bias']
   if args.vocab_transform:
      for w in ["weight", "bias"]:
         _A			=						state_dict[f"""cls.predictions.transform.dense.{w}"""]
         _A			=						state_dict[f"""cls.predictions.transform.LayerNorm.{w}"""]

   print(f"""N layers selected for distillation: {std_idx}""")
   print(f"""Number of params transferred for distillation: {len(compressed_sd.keys())}""")

   print(f"""Save transferred checkpoint to {args.dump_checkpoint}.""")
   torch.save(compressed_sd, args.dump_checkpoint)





