




'''simple docstring'''







import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


A     =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')
A     =parser.parse_args()


A     ='cpu'
A     ='a lovely <dicoo> in red dress and hat, in the snowly and brightly night, with many brighly buildings'

A     ='path-to-your-trained-model'
A     =StableDiffusionPipeline.from_pretrained(model_id)
if args.dpm:
   A     =DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
A     =pipe.to(device)

# to channels last
A     =pipe.unet.to(memory_format=torch.channels_last)
A     =pipe.vae.to(memory_format=torch.channels_last)
A     =pipe.text_encoder.to(memory_format=torch.channels_last)
if pipe.requires_safety_checker:
   A     =pipe.safety_checker.to(memory_format=torch.channels_last)

# optimize with ipex
A     =torch.randn(2, 4, 64, 64)
A     =torch.rand(1) * 9_99
A     =torch.randn(2, 77, 7_68)
A     =(sample, timestep, encoder_hidden_status)
try:
   A     =ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
   A     =ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
A     =ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
A     =ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
   A     =ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

# compute
A     =6_66
A     =torch.Generator(device).manual_seed(seed)
A     ={'generator': generator}
if args.steps is not None:
   A     =args.steps

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

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










'''simple docstring'''







import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
   A     ='pt'
elif is_tf_available():
   A     ='tf'
else:
   A     ='jax'


class 			_a  (	__a							,							unittest.TestCase ):
       __a				:     Optional[Any]   				=					PerceiverTokenizer
       __a				:     str   				=					False
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           super().setUp()
           UpperCAmelCase			       =		PerceiverTokenizer()
           tokenizer.save_pretrained(self.tmpdirname				)
       @cached_property
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           return PerceiverTokenizer.from_pretrained('''deepmind/language-perceiver'''				)
       def     A      (	self						:	Union[str, Any]   ,				**lowercase						:	int				):



           '''simple docstring'''

           return self.tokenizer_class.from_pretrained(self.tmpdirname   ,				**lowercase				)
       def     A      (	self						:	Tuple   ,				lowercase						:	str   ,				lowercase						:	List[str]=False   ,				lowercase						:	Union[str, Any]=20   ,				lowercase						:	Union[str, Any]=5				):



           '''simple docstring'''

           UpperCAmelCase			       =		[]
           for i in range(len(lowercase				)				):
               try:
                   UpperCAmelCase			       =		tokenizer.decode([i]   ,				clean_up_tokenization_spaces=lowercase				)
               except UnicodeDecodeError:
                   pass
               toks.append((i, tok)				)

           UpperCAmelCase			       =		list(filter(lambda lowercase				: re.match(R'''^[ a-zA-Z]+$'''   ,				t[1]				)   ,				lowercase				)				)
           UpperCAmelCase			       =		list(filter(lambda lowercase				: [t[0]] == tokenizer.encode(t[1]   ,				add_special_tokens=lowercase				)   ,				lowercase				)				)
           if max_length is not None and len(lowercase				) > max_length:
               UpperCAmelCase			       =		toks[:max_length]
           if min_length is not None and len(lowercase				) < min_length and len(lowercase				) > 0:
               while len(lowercase				) < min_length:
                   UpperCAmelCase			       =		toks + toks
        # toks_str = [t[1] for t in toks]
           UpperCAmelCase			       =		[t[0] for t in toks]

           # Ensure consistency
           UpperCAmelCase			       =		tokenizer.decode(lowercase   ,				clean_up_tokenization_spaces=lowercase				)
           if " " not in output_txt and len(lowercase				) > 1:
               UpperCAmelCase			       =		(
                   tokenizer.decode([toks_ids[0]]   ,				clean_up_tokenization_spaces=lowercase				)
                   + ''' '''
                   + tokenizer.decode(toks_ids[1:]   ,				clean_up_tokenization_spaces=lowercase				)
               )
           if with_prefix_space:
               UpperCAmelCase			       =		''' ''' + output_txt
           UpperCAmelCase			       =		tokenizer.encode(lowercase   ,				add_special_tokens=lowercase				)
           return output_txt, output_ids
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.perceiver_tokenizer
           UpperCAmelCase			       =		'''Unicode €.'''
           UpperCAmelCase			       =		tokenizer(lowercase				)
           UpperCAmelCase			       =		[4, 91, 116, 111, 105, 117, 106, 107, 38, 232, 136, 178, 52, 5]
           self.assertEqual(encoded['''input_ids''']   ,				lowercase				)

           # decoding
           UpperCAmelCase			       =		tokenizer.decode(lowercase				)
           self.assertEqual(lowercase   ,				'''[CLS]Unicode €.[SEP]'''				)

           UpperCAmelCase			       =		tokenizer('''e è é ê ë'''				)
           UpperCAmelCase			       =		[4, 107, 38, 201, 174, 38, 201, 175, 38, 201, 176, 38, 201, 177, 5]
           self.assertEqual(encoded['''input_ids''']   ,				lowercase				)
           # decoding
           UpperCAmelCase			       =		tokenizer.decode(lowercase				)
           self.assertEqual(lowercase   ,				'''[CLS]e è é ê ë[SEP]'''				)

           # encode/decode, but with `encode` instead of `__call__`
           self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë'''				)				)   ,				'''[CLS]e è é ê ë[SEP]'''				)
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.perceiver_tokenizer
           UpperCAmelCase			       =		['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
           # fmt: off
           UpperCAmelCase			       =		[4, 71, 38, 114, 117, 116, 109, 38, 118, 103, 120, 103, 109, 120, 103, 118, 110, 38, 108, 117, 120, 38, 121, 123, 115, 115, 103, 120, 111, 128, 103, 122, 111, 117, 116, 52, 5, 0]
           # fmt: on
           UpperCAmelCase			       =		tokenizer(lowercase   ,				padding=lowercase   ,				return_tensors=lowercase				)
           self.assertIsInstance(lowercase   ,				lowercase				)

           if FRAMEWORK != "jax":
               UpperCAmelCase			       =		list(batch.input_ids.numpy()[0]				)
           else:
               UpperCAmelCase			       =		list(batch.input_ids.tolist()[0]				)

           self.assertListEqual(lowercase   ,				lowercase				)

           self.assertEqual((2, 38)   ,				batch.input_ids.shape				)
           self.assertEqual((2, 38)   ,				batch.attention_mask.shape				)
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.perceiver_tokenizer
           UpperCAmelCase			       =		['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
           UpperCAmelCase			       =		tokenizer(lowercase   ,				padding=lowercase   ,				return_tensors=lowercase				)
           # check if input_ids are returned and no decoder_input_ids
           self.assertIn('''input_ids'''   ,				lowercase				)
           self.assertIn('''attention_mask'''   ,				lowercase				)
           self.assertNotIn('''decoder_input_ids'''   ,				lowercase				)
           self.assertNotIn('''decoder_attention_mask'''   ,				lowercase				)
       def     A      (	self						:	Dict				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.perceiver_tokenizer
           UpperCAmelCase			       =		[
               '''Summary of the text.''',
               '''Another summary.''',
           ]
           UpperCAmelCase			       =		tokenizer(
               text_target=lowercase   ,				max_length=32   ,				padding='''max_length'''   ,				truncation=lowercase   ,				return_tensors=lowercase				)
           self.assertEqual(32   ,				targets['''input_ids'''].shape[1]				)
       def     A      (	self						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_tokenizers()
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"				):
                   self.assertNotEqual(tokenizer.model_max_length   ,				42				)

        # Now let's start the test
           UpperCAmelCase			       =		self.get_tokenizers()
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"				):
                   # Isolate this from the other tests because we save additional tokens/etc
                   UpperCAmelCase			       =		tempfile.mkdtemp()

                   UpperCAmelCase			       =		''' He is very happy, UNwant\u00E9d,running'''
                   UpperCAmelCase			       =		tokenizer.encode(lowercase   ,				add_special_tokens=lowercase				)
                   tokenizer.save_pretrained(lowercase				)

                   UpperCAmelCase			       =		tokenizer.__class__.from_pretrained(lowercase				)
                   UpperCAmelCase			       =		after_tokenizer.encode(lowercase   ,				add_special_tokens=lowercase				)
                   self.assertListEqual(lowercase   ,				lowercase				)

                   shutil.rmtree(lowercase				)

           UpperCAmelCase			       =		self.get_tokenizers(model_max_length=42				)
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"				):
                   # Isolate this from the other tests because we save additional tokens/etc
                   UpperCAmelCase			       =		tempfile.mkdtemp()

                   UpperCAmelCase			       =		''' He is very happy, UNwant\u00E9d,running'''
                   tokenizer.add_tokens(['''bim''', '''bambam''']				)
                   UpperCAmelCase			       =		tokenizer.additional_special_tokens
                   additional_special_tokens.append('''new_additional_special_token'''				)
                   tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens}				)
                   UpperCAmelCase			       =		tokenizer.encode(lowercase   ,				add_special_tokens=lowercase				)
                   tokenizer.save_pretrained(lowercase				)

                   UpperCAmelCase			       =		tokenizer.__class__.from_pretrained(lowercase				)
                   UpperCAmelCase			       =		after_tokenizer.encode(lowercase   ,				add_special_tokens=lowercase				)
                   self.assertListEqual(lowercase   ,				lowercase				)
                   self.assertIn('''new_additional_special_token'''   ,				after_tokenizer.additional_special_tokens				)
                   self.assertEqual(after_tokenizer.model_max_length   ,				42				)

                   UpperCAmelCase			       =		tokenizer.__class__.from_pretrained(lowercase   ,				model_max_length=43				)
                   self.assertEqual(tokenizer.model_max_length   ,				43				)

                   shutil.rmtree(lowercase				)
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		[]
           if self.test_slow_tokenizer:
               tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())				)

           if self.test_rust_tokenizer:
               tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())				)

           for tokenizer_class, tokenizer_utils in tokenizer_list:
               with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer_utils.save_pretrained(lowercase				)

                   with open(os.path.join(lowercase   ,				'''special_tokens_map.json'''				)   ,				encoding='''utf-8'''				) as json_file:
                       UpperCAmelCase			       =		json.load(lowercase				)

                   with open(os.path.join(lowercase   ,				'''tokenizer_config.json'''				)   ,				encoding='''utf-8'''				) as json_file:
                       UpperCAmelCase			       =		json.load(lowercase				)

                   UpperCAmelCase			       =		[f"<extra_id_{i}>" for i in range(125				)]

                   UpperCAmelCase			       =		added_tokens_extra_ids + [
                       '''an_additional_special_token'''
                   ]
                   UpperCAmelCase			       =		added_tokens_extra_ids + [
                       '''an_additional_special_token'''
                   ]

                   with open(os.path.join(lowercase   ,				'''special_tokens_map.json'''				)   ,				'''w'''   ,				encoding='''utf-8'''				) as outfile:
                       json.dump(lowercase   ,				lowercase				)
                   with open(os.path.join(lowercase   ,				'''tokenizer_config.json'''				)   ,				'''w'''   ,				encoding='''utf-8'''				) as outfile:
                       json.dump(lowercase   ,				lowercase				)

                   # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                   # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                   # "special_tokens_map.json" files
                   UpperCAmelCase			       =		tokenizer_class.from_pretrained(
                       lowercase   ,				)
                   self.assertIn(
                       '''an_additional_special_token'''   ,				tokenizer_without_change_in_init.additional_special_tokens				)
                   self.assertEqual(
                       ['''an_additional_special_token''']   ,				tokenizer_without_change_in_init.convert_ids_to_tokens(
                           tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token''']				)				)   ,				)

                   # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                   UpperCAmelCase			       =		added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token'''   ,				lstrip=lowercase				)]
                   UpperCAmelCase			       =		tokenizer_class.from_pretrained(
                       lowercase   ,				additional_special_tokens=lowercase   ,				)

                   self.assertIn('''a_new_additional_special_token'''   ,				tokenizer.additional_special_tokens				)
                   self.assertEqual(
                       ['''a_new_additional_special_token''']   ,				tokenizer.convert_ids_to_tokens(
                           tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token''']				)				)   ,				)
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.perceiver_tokenizer
           self.assertEqual(tokenizer.decode([178]				)   ,				'''�'''				)
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           pass
       def     A      (	self						:	Any				):



           '''simple docstring'''

           pass
       def     A      (	self						:	Dict				):



           '''simple docstring'''

           pass
       def     A      (	self						:	str				):



           '''simple docstring'''

           pass







       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_tokenizers(fast=lowercase   ,				do_lower_case=lowercase				)
           for tokenizer in tokenizers:
               with self.subTest(f"{tokenizer.__class__.__name__}"				):
                   UpperCAmelCase			       =		['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]''']
                   UpperCAmelCase			       =		tokenizer.convert_tokens_to_string(lowercase				)

                   self.assertIsInstance(lowercase   ,				lowercase				)




