




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__     :     Any		    =       parser.parse_args()


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

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

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

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

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

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

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






import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()

def lowercase    (  SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )			->							Union[str, Any]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						FunnelConfig.from_json_file(SCREAMING_SNAKE_CASE )
			print(F'Building PyTorch model from configuration: {config}' )
			SCREAMING_SNAKE_CASE_								=						FunnelBaseModel(SCREAMING_SNAKE_CASE ) if base_model else FunnelModel(SCREAMING_SNAKE_CASE )

			# Load weights from tf checkpoint
			load_tf_weights_in_funnel(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )

			# Save pytorch-model
			print(F'Save PyTorch model to {pytorch_dump_path}' )
			torch.save(model.state_dict()       ,    SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
				SCREAMING_SNAKE_CASE__     :     Union[str, Any]		    =       argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
				)
				parser.add_argument(
				    "--config_file",
				    default=None,
				    type=str,
				    required=True,
				    help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
				)
				parser.add_argument(
				    "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
				)
				parser.add_argument(
				    "--base_model", action="store_true", help="Whether you want just the base model (no decoder) or not."
				)
				SCREAMING_SNAKE_CASE__     :     List[Any]		    =       parser.parse_args()
				convert_tf_checkpoint_to_pytorch(
				    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
				)
