



"""simple docstring"""






import unittest

from transformers import AutoTokenizer, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow


if is_flax_available():
     import jax.numpy as jnp

     from transformers import FlaxXLMRobertaModel



@require_sentencepiece
@require_tokenizers
@require_flax
class     UpperCAmelCase    (	unittest.TestCase  ):



   @slow
   def    __UpperCAmelCase    (       self    :	int				):



     """simple docstring"""
     _snake_case   	=      FlaxXLMRobertaModel.from_pretrained('''xlm-roberta-base'''				)
     _snake_case   	=      AutoTokenizer.from_pretrained('''xlm-roberta-base'''				)
     _snake_case   	=      '''The dog is cute and lives in the garden house'''
     _snake_case   	=      jnp.array([tokenizer.encode(__lowerCamelCase				)]				)

     _snake_case   	=      (1, 1_2, 7_6_8)  # batch_size, sequence_length, embedding_vector_dim
     _snake_case   	=      jnp.array(
         [[-0.0_1_0_1, 0.1_2_1_8, -0.0_8_0_3, 0.0_8_0_1, 0.1_3_2_7, 0.0_7_7_6, -0.1_2_1_5, 0.2_3_8_3, 0.3_3_3_8, 0.3_1_0_6, 0.0_3_0_0, 0.0_2_5_2]]				)

     _snake_case   	=      model(__lowerCamelCase				)['''last_hidden_state''']
     self.assertEqual(output.shape							,       __lowerCamelCase				)
     # compare the actual values for a slice of last dim
     self.assertTrue(jnp.allclose(output[:, :, -1]							,       __lowerCamelCase							,       atol=1E-3				)				)












import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


SCREAMING_SNAKE_CASE__							:      List[str]         =    argparse.ArgumentParser("""Stable Diffusion script with intel optimization""", add_help=False)
parser.add_argument("""--dpm""", action="""store_true""", help="""Enable DPMSolver or not""")
parser.add_argument("""--steps""", default=None, type=int, help="""Num inference steps""")
SCREAMING_SNAKE_CASE__							:      Tuple         =    parser.parse_args()


SCREAMING_SNAKE_CASE__							:      int         =    """cpu"""
SCREAMING_SNAKE_CASE__							:      Optional[Any]         =    """a lovely <dicoo> in red dress and hat, in the snowly and brightly night, with many brighly buildings"""

SCREAMING_SNAKE_CASE__							:      List[Any]         =    """path-to-your-trained-model"""
SCREAMING_SNAKE_CASE__							:      Tuple         =    StableDiffusionPipeline.from_pretrained(model_id)
if args.dpm:
  SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
SCREAMING_SNAKE_CASE__							:      Optional[int]         =    pipe.to(device)

# to channels last
SCREAMING_SNAKE_CASE__							:      int         =    pipe.unet.to(memory_format=torch.channels_last)
SCREAMING_SNAKE_CASE__							:      List[Any]         =    pipe.vae.to(memory_format=torch.channels_last)
SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    pipe.text_encoder.to(memory_format=torch.channels_last)
if pipe.requires_safety_checker:
  SCREAMING_SNAKE_CASE__							:      List[str]         =    pipe.safety_checker.to(memory_format=torch.channels_last)

# optimize with ipex
SCREAMING_SNAKE_CASE__							:      Optional[int]         =    torch.randn(2, 4, 6_4, 6_4)
SCREAMING_SNAKE_CASE__							:      Any         =    torch.rand(1) * 9_9_9
SCREAMING_SNAKE_CASE__							:      List[Any]         =    torch.randn(2, 7_7, 7_6_8)
SCREAMING_SNAKE_CASE__							:      Optional[Any]         =    (sample, timestep, encoder_hidden_status)
try:
  SCREAMING_SNAKE_CASE__							:      Any         =    ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
  SCREAMING_SNAKE_CASE__							:      Optional[Any]         =    ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
SCREAMING_SNAKE_CASE__							:      str         =    ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
  SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

# compute
SCREAMING_SNAKE_CASE__							:      Optional[Any]         =    6_6_6
SCREAMING_SNAKE_CASE__							:      Any         =    torch.Generator(device).manual_seed(seed)
SCREAMING_SNAKE_CASE__							:      int         =    {"""generator""": generator}
if args.steps is not None:
  SCREAMING_SNAKE_CASE__							:      Optional[int]         =    args.steps

with torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloataa):
  SCREAMING_SNAKE_CASE__							:      Dict         =    pipe(prompt, **generate_kwargs).images[0]

# save image
image.save("""generated.png""")

