

'''simple docstring'''
import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference







class 							A__    (       A_     ,   unittest.TestCase  ):
  A__		 =				ShapEImgaImgPipeline
  A__		 =				['image']
  A__		 =				['image']
  A__		 =				[
      'num_images_per_prompt',
      'num_inference_steps',
      'generator',
      'latents',
      'guidance_scale',
      'frame_size',
      'output_type',
      'return_dict',
  ]
  A__		 =				False





  @property
  def 						A  (		self      :	str )	->    List[str]:





       '''simple docstring'''






       return 32





  @property
  def 						A  (		self      :	Optional[int] )	->    Tuple:





       '''simple docstring'''






       return 32





  @property
  def 						A  (		self      :	Union[str, Any] )	->    int:





       '''simple docstring'''






       return self.time_input_dim * 4





  @property
  def 						A  (		self      :	Tuple )	->    Union[str, Any]:





       '''simple docstring'''






       return 8





  @property
  def 						A  (		self      :	Optional[Any] )	->    Dict:





       '''simple docstring'''






       torch.manual_seed(0 )
       _SCREAMING_SNAKE_CASE							    =CLIPVisionConfig(
           hidden_size=self.text_embedder_hidden_size							,					image_size=64							,					projection_dim=self.text_embedder_hidden_size							,					intermediate_size=37							,					num_attention_heads=4							,					num_channels=3							,					num_hidden_layers=5							,					patch_size=1							,					)

       _SCREAMING_SNAKE_CASE							    =CLIPVisionModel(_lowerCamelCase )
       return model





  @property
  def 						A  (		self      :	List[str] )	->    int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =CLIPImageProcessor(
           crop_size=224							,					do_center_crop=_lowerCamelCase							,					do_normalize=_lowerCamelCase							,					do_resize=_lowerCamelCase							,					image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]							,					image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]							,					resample=3							,					size=224							,					)

       return image_processor





  @property
  def 						A  (		self      :	List[str] )	->    Tuple:





       '''simple docstring'''






       torch.manual_seed(0 )

       _SCREAMING_SNAKE_CASE							    ={
           'num_attention_heads': 2,
           'attention_head_dim': 16,
           'embedding_dim': self.time_input_dim,
           'num_embeddings': 32,
           'embedding_proj_dim': self.text_embedder_hidden_size,
           'time_embed_dim': self.time_embed_dim,
           'num_layers': 1,
           'clip_embed_dim': self.time_input_dim * 2,
           'additional_embeddings': 0,
           'time_embed_act_fn': 'gelu',
           'norm_in_type': 'layer',
           'embedding_proj_norm_type': 'layer',
           'encoder_hid_proj_type': None,
           'added_emb_type': None,
       }

       _SCREAMING_SNAKE_CASE							    =PriorTransformer(**_lowerCamelCase )
       return model





  @property
  def 						A  (		self      :	Optional[Any] )	->    Tuple:





       '''simple docstring'''






       torch.manual_seed(0 )

       _SCREAMING_SNAKE_CASE							    ={
           'param_shapes': (
               (self.renderer_dim, 93),
               (self.renderer_dim, 8),
               (self.renderer_dim, 8),
               (self.renderer_dim, 8),
           ),
           'd_latent': self.time_input_dim,
           'd_hidden': self.renderer_dim,
           'n_output': 12,
           'background': (
               0.1,
               0.1,
               0.1,
           ),
       }
       _SCREAMING_SNAKE_CASE							    =ShapERenderer(**_lowerCamelCase )
       return model





  def 						A  (		self      :	Dict )	->    Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.dummy_prior
       _SCREAMING_SNAKE_CASE							    =self.dummy_image_encoder
       _SCREAMING_SNAKE_CASE							    =self.dummy_image_processor
       _SCREAMING_SNAKE_CASE							    =self.dummy_renderer

       _SCREAMING_SNAKE_CASE							    =HeunDiscreteScheduler(
           beta_schedule='exp'							,					num_train_timesteps=1024							,					prediction_type='sample'							,					use_karras_sigmas=_lowerCamelCase							,					clip_sample=_lowerCamelCase							,					clip_sample_range=1.0							,					)
       _SCREAMING_SNAKE_CASE							    ={
           'prior': prior,
           'image_encoder': image_encoder,
           'image_processor': image_processor,
           'renderer': renderer,
           'scheduler': scheduler,
       }

       return components





  def 						A  (		self      :	Any							,					_a      :	Tuple							,					_a      :	Union[str, Any]=0 )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =floats_tensor((1, 3, 64, 64)							,					rng=random.Random(_lowerCamelCase ) ).to(_lowerCamelCase )

       if str(_lowerCamelCase ).startswith('mps' ):
            _SCREAMING_SNAKE_CASE							    =torch.manual_seed(_lowerCamelCase )
       else:
            _SCREAMING_SNAKE_CASE							    =torch.Generator(device=_lowerCamelCase ).manual_seed(_lowerCamelCase )
       _SCREAMING_SNAKE_CASE							    ={
           'image': input_image,
           'generator': generator,
           'num_inference_steps': 1,
           'frame_size': 32,
           'output_type': 'np',
       }
       return inputs





  def 						A  (		self      :	Union[str, Any] )	->    Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    ='cpu'

       _SCREAMING_SNAKE_CASE							    =self.get_dummy_components()

       _SCREAMING_SNAKE_CASE							    =self.pipeline_class(**_lowerCamelCase )
       _SCREAMING_SNAKE_CASE							    =pipe.to(_lowerCamelCase )

       pipe.set_progress_bar_config(disable=_lowerCamelCase )

       _SCREAMING_SNAKE_CASE							    =pipe(**self.get_dummy_inputs(_lowerCamelCase ) )
       _SCREAMING_SNAKE_CASE							    =output.images[0]
       _SCREAMING_SNAKE_CASE							    =image[0, -3:, -3:, -1]

       assert image.shape == (20, 32, 32, 3)

       _SCREAMING_SNAKE_CASE							    =np.array(
           [
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
               0.00_03_92_16,
           ] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2





  def 						A  (		self      :	Tuple )	->    Optional[int]:





       '''simple docstring'''






       self._test_inference_batch_consistent(batch_sizes=[1, 2] )





  def 						A  (		self      :	str )	->    Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =torch_device == 'cpu'
       _SCREAMING_SNAKE_CASE							    =True
       self._test_inference_batch_single_identical(
           batch_size=2							,					test_max_difference=_lowerCamelCase							,					relax_max_difference=_lowerCamelCase							,					)





  def 						A  (		self      :	List[Any] )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.get_dummy_components()
       _SCREAMING_SNAKE_CASE							    =self.pipeline_class(**_lowerCamelCase )
       _SCREAMING_SNAKE_CASE							    =pipe.to(_lowerCamelCase )
       pipe.set_progress_bar_config(disable=_lowerCamelCase )

       _SCREAMING_SNAKE_CASE							    =1
       _SCREAMING_SNAKE_CASE							    =2

       _SCREAMING_SNAKE_CASE							    =self.get_dummy_inputs(_lowerCamelCase )

       for key in inputs.keys():
            if key in self.batch_params:
                 _SCREAMING_SNAKE_CASE							    =batch_size * [inputs[key]]

       _SCREAMING_SNAKE_CASE							    =pipe(**_lowerCamelCase							,					num_images_per_prompt=_lowerCamelCase )[0]

       assert images.shape[0] == batch_size * num_images_per_prompt







@slow
@require_torch_gpu
class 							A__    (       unittest.TestCase  ):





  def 						A  (		self      :	Union[str, Any] )	->    Union[str, Any]:





       '''simple docstring'''






       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()





  def 						A  (		self      :	List[Any] )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =load_image(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png' )
       _SCREAMING_SNAKE_CASE							    =load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
           '/shap_e/test_shap_e_img2img_out.npy' )
       _SCREAMING_SNAKE_CASE							    =ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img' )
       _SCREAMING_SNAKE_CASE							    =pipe.to(_lowerCamelCase )
       pipe.set_progress_bar_config(disable=_lowerCamelCase )

       _SCREAMING_SNAKE_CASE							    =torch.Generator(device=_lowerCamelCase ).manual_seed(0 )

       _SCREAMING_SNAKE_CASE							    =pipe(
           _lowerCamelCase							,					generator=_lowerCamelCase							,					guidance_scale=3.0							,					num_inference_steps=64							,					frame_size=64							,					output_type='np'							,					).images[0]

       assert images.shape == (20, 64, 64, 3)

       assert_mean_pixel_difference(_lowerCamelCase							,					_lowerCamelCase )


"""simple docstring"""



import argparse

import torch

from transformers import BertForMaskedLM


if __name__ == "__main__":
 UpperCAmelCase__          = 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')
 UpperCAmelCase__          = parser.parse_args()

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

 UpperCAmelCase__          = model.state_dict()
 UpperCAmelCase__          = {}

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

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

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

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

 UpperCAmelCase__          = state_dict['cls.predictions.decoder.weight']
 UpperCAmelCase__          = state_dict['cls.predictions.bias']
 if args.vocab_transform:
  for w in ["weight", "bias"]:
   UpperCAmelCase__          = state_dict[F"cls.predictions.transform.dense.{w}"]
   UpperCAmelCase__          = 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)



