


'''simple docstring'''







import tempfile
import unittest

import torch

from diffusers import UNetaDConditionModel
from diffusers.training_utils import EMAModel
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps, torch_device


enable_full_determinism()
class  lowercase_					(   unittest.TestCase       ):
    __UpperCAmelCase             =     'hf-internal-testing/tiny-stable-diffusion-pipe'
    __UpperCAmelCase             =     1
    __UpperCAmelCase             =     77
    __UpperCAmelCase             =     32
    __UpperCAmelCase             =     4
    __UpperCAmelCase             =     __UpperCAmelCase             =     64
    __UpperCAmelCase             =     torch.manual_seed(0       )


    def        __a							(					self  , a=0.9999   ):
          UpperCamelCase__  =    UNetaDConditionModel.from_pretrained(self.model_id  , subfolder="unet"   )
          UpperCamelCase__  =    unet.to(a   )
          UpperCamelCase__  =    EMAModel(unet.parameters()  , decay=a  , model_cls=a  , model_config=unet.config   )
          return unet, ema_unet


    def        __a							(					self   ):
          UpperCamelCase__  =    torch.randn(
              self.batch_size  , self.num_in_channels  , self.latent_height  , self.latent_width  , generator=self.generator   ).to(a   )
          UpperCamelCase__  =    torch.randint(0  , 10_00  , size=(self.batch_size,)  , generator=self.generator   ).to(a   )
          UpperCamelCase__  =    torch.randn(
              self.batch_size  , self.prompt_length  , self.text_encoder_hidden_dim  , generator=self.generator   ).to(a   )
          return noisy_latents, timesteps, encoder_hidden_states


    def        __a							(					self  , a   ):
          UpperCamelCase__  =    {}
          for k, param in unet.state_dict().items():
                UpperCamelCase__  =    torch.randn_like(a   ) + (param * torch.randn_like(a   ))
                updated_state_dict.update({k: updated_param}   )
          unet.load_state_dict(a   )
          return unet


    def        __a							(					self   ):
          UpperCamelCase__ ,     UpperCamelCase__  =    self.get_models()
          # Take the first (hypothetical) EMA step.
          ema_unet.step(unet.parameters()   )
          assert ema_unet.optimization_step == 1

          # Take two more.
          for _ in range(2   ):
                ema_unet.step(unet.parameters()   )
          assert ema_unet.optimization_step == 3


    def        __a							(					self   ):
          UpperCamelCase__ ,     UpperCamelCase__  =    self.get_models()
          # Since the `unet` is not being updated (i.e., backprop'd)
          # there won't be any difference between the `params` of `unet`
          # and `ema_unet` even if we call `ema_unet.step(unet.parameters())`.
          ema_unet.step(unet.parameters()   )
          UpperCamelCase__  =    list(unet.parameters()   )
          for s_param, param in zip(ema_unet.shadow_params  , a   ):
                assert torch.allclose(a  , a   )

          # The above holds true even if we call `ema.step()` multiple times since
          # `unet` params are still not being updated.
          for _ in range(4   ):
                ema_unet.step(unet.parameters()   )
          for s_param, param in zip(ema_unet.shadow_params  , a   ):
                assert torch.allclose(a  , a   )


    def        __a							(					self   ):
          UpperCamelCase__ ,     UpperCamelCase__  =    self.get_models()
          # Here we simulate the parameter updates for `unet`. Since there might
          # be some parameters which are initialized to zero we take extra care to
          # initialize their values to something non-zero before the multiplication.
          UpperCamelCase__  =    self.simulate_backprop(a   )

          # Take the EMA step.
          ema_unet.step(unet_pseudo_updated_step_one.parameters()   )

          # Now the EMA'd parameters won't be equal to the original model parameters.
          UpperCamelCase__  =    list(unet_pseudo_updated_step_one.parameters()   )
          for s_param, param in zip(ema_unet.shadow_params  , a   ):
                assert ~torch.allclose(a  , a   )

          # Ensure this is the case when we take multiple EMA steps.
          for _ in range(4   ):
                ema_unet.step(unet.parameters()   )
          for s_param, param in zip(ema_unet.shadow_params  , a   ):
                assert ~torch.allclose(a  , a   )


    def        __a							(					self   ):
          # If we call EMA step after a backpropagation consecutively for two times,
          # the shadow params from those two steps should be different.
          UpperCamelCase__ ,     UpperCamelCase__  =    self.get_models()

          # First backprop + EMA
          UpperCamelCase__  =    self.simulate_backprop(a   )
          ema_unet.step(unet_step_one.parameters()   )
          UpperCamelCase__  =    ema_unet.shadow_params

          # Second backprop + EMA
          UpperCamelCase__  =    self.simulate_backprop(a   )
          ema_unet.step(unet_step_two.parameters()   )
          UpperCamelCase__  =    ema_unet.shadow_params

          for step_one, step_two in zip(a  , a   ):
                assert ~torch.allclose(a  , a   )


    def        __a							(					self   ):
          # If there's no decay even if there are backprops, EMA steps
          # won't take any effect i.e., the shadow params would remain the
          # same.
          UpperCamelCase__ ,     UpperCamelCase__  =    self.get_models(decay=0.0   )
          UpperCamelCase__  =    self.simulate_backprop(a   )
          ema_unet.step(unet_step_one.parameters()   )
          UpperCamelCase__  =    ema_unet.shadow_params

          UpperCamelCase__  =    self.simulate_backprop(a   )
          ema_unet.step(unet_step_two.parameters()   )
          UpperCamelCase__  =    ema_unet.shadow_params

          for step_one, step_two in zip(a  , a   ):
                assert torch.allclose(a  , a   )


    @skip_mps
    def        __a							(					self   ):
          UpperCamelCase__ ,     UpperCamelCase__  =    self.get_models()
          UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__  =    self.get_dummy_inputs()

          with tempfile.TemporaryDirectory() as tmpdir:
                ema_unet.save_pretrained(a   )
                UpperCamelCase__  =    UNetaDConditionModel.from_pretrained(a  , model_cls=a   )
                UpperCamelCase__  =    loaded_unet.to(unet.device   )

          # Since no EMA step has been performed the outputs should match.
          UpperCamelCase__  =    unet(a  , a  , a   ).sample
          UpperCamelCase__  =    loaded_unet(a  , a  , a   ).sample

          assert torch.allclose(a  , a  , atol=1e-4   )









'''simple docstring'''







import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
  from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

  from .test_feature_extraction_speechta import floats_list


a__  : int				=	get_tests_dir('fixtures/test_sentencepiece_bpe_char.model')
@require_torch
class  lowercase_					(   unittest.TestCase       ):


    def        __a							(					self   ):
          UpperCamelCase__  =    tempfile.mkdtemp()

          UpperCamelCase__  =    SpeechTaTokenizer(a   )
          tokenizer.save_pretrained(self.tmpdirname   )

          UpperCamelCase__  =    {
              "feature_size": 1,
              "padding_value": 0.0,
              "sampling_rate": 1_60_00,
              "do_normalize": False,
              "num_mel_bins": 80,
              "hop_length": 16,
              "win_length": 64,
              "win_function": "hann_window",
              "fmin": 80,
              "fmax": 76_00,
              "mel_floor": 1e-10,
              "reduction_factor": 2,
              "return_attention_mask": True,
          }

          UpperCamelCase__  =    os.path.join(self.tmpdirname  , a   )
          with open(self.feature_extraction_file  , "w"  , encoding="utf-8"   ) as fp:
                fp.write(json.dumps(a   ) + "\n"   )


    def        __a							(					self  , **a   ):
          return SpeechTaTokenizer.from_pretrained(self.tmpdirname  , **a   )


    def        __a							(					self  , **a   ):
          return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname  , **a   )


    def        __a							(					self   ):
          shutil.rmtree(self.tmpdirname   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_tokenizer()
          UpperCamelCase__  =    self.get_feature_extractor()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          processor.save_pretrained(self.tmpdirname   )
          UpperCamelCase__  =    SpeechTaProcessor.from_pretrained(self.tmpdirname   )

          self.assertEqual(processor.tokenizer.get_vocab()  , tokenizer.get_vocab()   )
          self.assertIsInstance(processor.tokenizer  , a   )

          self.assertEqual(processor.feature_extractor.to_json_string()  , feature_extractor.to_json_string()   )
          self.assertIsInstance(processor.feature_extractor  , a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=self.get_tokenizer()  , feature_extractor=self.get_feature_extractor()   )
          processor.save_pretrained(self.tmpdirname   )

          UpperCamelCase__  =    self.get_tokenizer(bos_token="(BOS)"  , eos_token="(EOS)"   )
          UpperCamelCase__  =    self.get_feature_extractor(do_normalize=a  , padding_value=1.0   )

          UpperCamelCase__  =    SpeechTaProcessor.from_pretrained(
              self.tmpdirname  , bos_token="(BOS)"  , eos_token="(EOS)"  , do_normalize=a  , padding_value=1.0   )

          self.assertEqual(processor.tokenizer.get_vocab()  , tokenizer_add_kwargs.get_vocab()   )
          self.assertIsInstance(processor.tokenizer  , a   )

          self.assertEqual(processor.feature_extractor.to_json_string()  , feature_extractor_add_kwargs.to_json_string()   )
          self.assertIsInstance(processor.feature_extractor  , a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_feature_extractor()
          UpperCamelCase__  =    self.get_tokenizer()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          UpperCamelCase__  =    floats_list((3, 10_00)   )

          UpperCamelCase__  =    feature_extractor(audio=a  , return_tensors="np"   )
          UpperCamelCase__  =    processor(audio=a  , return_tensors="np"   )

          for key in input_feat_extract.keys():
                self.assertAlmostEqual(input_feat_extract[key].sum()  , input_processor[key].sum()  , delta=1e-2   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_feature_extractor()
          UpperCamelCase__  =    self.get_tokenizer()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          UpperCamelCase__  =    floats_list((3, 10_00)   )

          UpperCamelCase__  =    feature_extractor(audio_target=a  , return_tensors="np"   )
          UpperCamelCase__  =    processor(audio_target=a  , return_tensors="np"   )

          for key in input_feat_extract.keys():
                self.assertAlmostEqual(input_feat_extract[key].sum()  , input_processor[key].sum()  , delta=1e-2   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_feature_extractor()
          UpperCamelCase__  =    self.get_tokenizer()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          UpperCamelCase__  =    "This is a test string"

          UpperCamelCase__  =    processor(text=a   )
          UpperCamelCase__  =    tokenizer(a   )

          for key in encoded_tok.keys():
                self.assertListEqual(encoded_tok[key]  , encoded_processor[key]   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_feature_extractor()
          UpperCamelCase__  =    self.get_tokenizer()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          UpperCamelCase__  =    "This is a test string"

          UpperCamelCase__  =    processor(text_target=a   )
          UpperCamelCase__  =    tokenizer(a   )

          for key in encoded_tok.keys():
                self.assertListEqual(encoded_tok[key]  , encoded_processor[key]   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_feature_extractor()
          UpperCamelCase__  =    self.get_tokenizer()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          UpperCamelCase__  =    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          UpperCamelCase__  =    processor.batch_decode(a   )
          UpperCamelCase__  =    tokenizer.batch_decode(a   )

          self.assertListEqual(a  , a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_feature_extractor()
          UpperCamelCase__  =    self.get_tokenizer()

          UpperCamelCase__  =    SpeechTaProcessor(tokenizer=a  , feature_extractor=a   )

          self.assertListEqual(
              processor.model_input_names  , feature_extractor.model_input_names  , msg="`processor` and `feature_extractor` model input names do not match"  , )





