


'''simple docstring'''



import argparse
import os

import numpy as np
import tensorflow as tf
import torch

from transformers import BertModel



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				BertModel      ,    UpperCAmelCase_    :				str      ,    UpperCAmelCase_    :				str							)     ->		List[Any]:
     __lowerCamelCase   :	Optional[int]								=		('dense.weight', 'attention.self.query', 'attention.self.key', 'attention.self.value')

     __lowerCamelCase   :	Any								=		(
         ('layer.', 'layer_'),
         ('word_embeddings.weight', 'word_embeddings'),
         ('position_embeddings.weight', 'position_embeddings'),
         ('token_type_embeddings.weight', 'token_type_embeddings'),
         ('.', '/'),
         ('LayerNorm/weight', 'LayerNorm/gamma'),
         ('LayerNorm/bias', 'LayerNorm/beta'),
         ('weight', 'kernel'),
     )

     if not os.path.isdir(UpperCAmelCase_							):
          os.makedirs(UpperCAmelCase_							)

     __lowerCamelCase   :	str								=		model.state_dict()

     def to_tf_var_name(UpperCAmelCase_    :				str							):
          for patt, repl in iter(UpperCAmelCase_							):
               __lowerCamelCase   :	str								=		name.replace(UpperCAmelCase_      ,    UpperCAmelCase_							)
          return F'bert/{name}'

     def create_tf_var(UpperCAmelCase_    :				np.ndarray      ,    UpperCAmelCase_    :				str      ,    UpperCAmelCase_    :				tf.Session							):
          __lowerCamelCase   :	str								=		tf.dtypes.as_dtype(tensor.dtype							)
          __lowerCamelCase   :	Dict								=		tf.get_variable(dtype=UpperCAmelCase_      ,    shape=tensor.shape      ,    name=UpperCAmelCase_      ,    initializer=tf.zeros_initializer()							)
          session.run(tf.variables_initializer([tf_var]							)							)
          session.run(UpperCAmelCase_							)
          return tf_var

     tf.reset_default_graph()
     with tf.Session() as session:
          for var_name in state_dict:
               __lowerCamelCase   :	List[Any]								=		to_tf_var_name(UpperCAmelCase_							)
               __lowerCamelCase   :	List[str]								=		state_dict[var_name].numpy()
               if any(x in var_name for x in tensors_to_transpose							):
                    __lowerCamelCase   :	List[str]								=		torch_tensor.T
               __lowerCamelCase   :	str								=		create_tf_var(tensor=UpperCAmelCase_      ,    name=UpperCAmelCase_      ,    session=UpperCAmelCase_							)
               tf.keras.backend.set_value(UpperCAmelCase_      ,    UpperCAmelCase_							)
               __lowerCamelCase   :	int								=		session.run(UpperCAmelCase_							)
               print(F'Successfully created {tf_name}: {np.allclose(UpperCAmelCase_      ,    UpperCAmelCase_							)}'							)

          __lowerCamelCase   :	List[str]								=		tf.train.Saver(tf.trainable_variables()							)
          saver.save(UpperCAmelCase_      ,    os.path.join(UpperCAmelCase_      ,    model_name.replace('-'      ,    '_'							) + '.ckpt'							)							)



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				List[Any]=None							)     ->		Union[str, Any]:
     __lowerCamelCase   :	Optional[int]								=		argparse.ArgumentParser()
     parser.add_argument('--model_name'      ,    type=UpperCAmelCase_      ,    required=UpperCAmelCase_      ,    help='model name e.g. bert-base-uncased'							)
     parser.add_argument(
         '--cache_dir'      ,    type=UpperCAmelCase_      ,    default=UpperCAmelCase_      ,    required=UpperCAmelCase_      ,    help='Directory containing pytorch model'							)
     parser.add_argument('--pytorch_model_path'      ,    type=UpperCAmelCase_      ,    required=UpperCAmelCase_      ,    help='/path/to/<pytorch-model-name>.bin'							)
     parser.add_argument('--tf_cache_dir'      ,    type=UpperCAmelCase_      ,    required=UpperCAmelCase_      ,    help='Directory in which to save tensorflow model'							)
     __lowerCamelCase   :	Optional[int]								=		parser.parse_args(UpperCAmelCase_							)

     __lowerCamelCase   :	int								=		BertModel.from_pretrained(
         pretrained_model_name_or_path=args.model_name      ,    state_dict=torch.load(args.pytorch_model_path							)      ,    cache_dir=args.cache_dir      ,    )

     convert_pytorch_checkpoint_to_tf(model=UpperCAmelCase_      ,    ckpt_dir=args.tf_cache_dir      ,    model_name=args.model_name							)


if __name__ == "__main__":
      main()










'''simple docstring'''



import unittest

import numpy as np

from diffusers import LMSDiscreteScheduler, OnnxStableDiffusionInpaintPipeline
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
      import onnxruntime as ort





class    UpperCAmelCase_  (_UpperCAmelCase					,		unittest.TestCase  ):





    """simple docstring"""






    pass







@nightly
@require_onnxruntime
@require_torch_gpu
class    UpperCAmelCase_  (unittest.TestCase  ):





    """simple docstring"""






    @property
    def       lowercase_				(							self	)				->     int:
         return (
             "CUDAExecutionProvider",
             {
                 "gpu_mem_limit": "15000000000",  # 15GB
                 "arena_extend_strategy": "kSameAsRequested",
             },
         )







    @property
    def       lowercase_				(							self	)				->     Dict:
         __lowerCamelCase   :	int								=		ort.SessionOptions()
         __lowerCamelCase   :	Optional[Any]								=		False
         return options







    def       lowercase_				(							self	)				->     Union[str, Any]:
         __lowerCamelCase   :	Any								=		load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/in_paint/overture-creations-5sI6fQgYIuo.png'	)
         __lowerCamelCase   :	Any								=		load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/in_paint/overture-creations-5sI6fQgYIuo_mask.png'	)
         __lowerCamelCase   :	Any								=		OnnxStableDiffusionInpaintPipeline.from_pretrained(
             'runwayml/stable-diffusion-inpainting'			,     revision='onnx'			,     safety_checker=SCREAMING_SNAKE_CASE_			,     feature_extractor=SCREAMING_SNAKE_CASE_			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
         pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	Tuple								=		'A red cat sitting on a park bench'

         __lowerCamelCase   :	Union[str, Any]								=		np.random.RandomState(0	)
         __lowerCamelCase   :	Union[str, Any]								=		pipe(
             prompt=SCREAMING_SNAKE_CASE_			,     image=SCREAMING_SNAKE_CASE_			,     mask_image=SCREAMING_SNAKE_CASE_			,     guidance_scale=7.5			,     num_inference_steps=10			,     generator=SCREAMING_SNAKE_CASE_			,     output_type='np'			,     )
         __lowerCamelCase   :	Optional[Any]								=		output.images
         __lowerCamelCase   :	Tuple								=		images[0, 2_55:2_58, 2_55:2_58, -1]

         assert images.shape == (1, 5_12, 5_12, 3)
         __lowerCamelCase   :	Union[str, Any]								=		np.array([0.2_5_1_4, 0.3_0_0_7, 0.3_5_1_7, 0.1_7_9_0, 0.2_3_8_2, 0.3_1_6_7, 0.1_9_4_4, 0.2_2_7_3, 0.2_4_6_4]	)

         assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-3







    def       lowercase_				(							self	)				->     Optional[Any]:
         __lowerCamelCase   :	Union[str, Any]								=		load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/in_paint/overture-creations-5sI6fQgYIuo.png'	)
         __lowerCamelCase   :	List[str]								=		load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/in_paint/overture-creations-5sI6fQgYIuo_mask.png'	)
         __lowerCamelCase   :	Dict								=		LMSDiscreteScheduler.from_pretrained(
             'runwayml/stable-diffusion-inpainting'			,     subfolder='scheduler'			,     revision='onnx'	)
         __lowerCamelCase   :	Tuple								=		OnnxStableDiffusionInpaintPipeline.from_pretrained(
             'runwayml/stable-diffusion-inpainting'			,     revision='onnx'			,     scheduler=SCREAMING_SNAKE_CASE_			,     safety_checker=SCREAMING_SNAKE_CASE_			,     feature_extractor=SCREAMING_SNAKE_CASE_			,     provider=self.gpu_provider			,     sess_options=self.gpu_options			,     )
         pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

         __lowerCamelCase   :	str								=		'A red cat sitting on a park bench'

         __lowerCamelCase   :	Tuple								=		np.random.RandomState(0	)
         __lowerCamelCase   :	Optional[int]								=		pipe(
             prompt=SCREAMING_SNAKE_CASE_			,     image=SCREAMING_SNAKE_CASE_			,     mask_image=SCREAMING_SNAKE_CASE_			,     guidance_scale=7.5			,     num_inference_steps=20			,     generator=SCREAMING_SNAKE_CASE_			,     output_type='np'			,     )
         __lowerCamelCase   :	List[str]								=		output.images
         __lowerCamelCase   :	Dict								=		images[0, 2_55:2_58, 2_55:2_58, -1]

         assert images.shape == (1, 5_12, 5_12, 3)
         __lowerCamelCase   :	Tuple								=		np.array([0.0_0_8_6, 0.0_0_7_7, 0.0_0_8_3, 0.0_0_9_3, 0.0_1_0_7, 0.0_1_3_9, 0.0_0_9_4, 0.0_0_9_7, 0.0_1_2_5]	)

         assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-3






