



"""simple docstring"""







import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
     from test_module.custom_tokenization_fast import CustomTokenizerFast







class       UpperCamelCase__   (	unittest.TestCase  ):




      """simple docstring"""




      def      SCREAMING_SNAKE_CASE__ (      self				:      List[Any]       ):
        # A mock response for an HTTP head request to emulate server down
        lowerCAmelCase_   :				Union[str, Any]								= mock.Mock()
        lowerCAmelCase_   :				Dict								= 5_0_0
        lowerCAmelCase_   :				List[str]								= {}
        lowerCAmelCase_   :				Dict								= HTTPError
        lowerCAmelCase_   :				Any								= {}

        # Download this model to make sure it's in the cache.
        lowerCAmelCase_   :				Union[str, Any]								= BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'       )

        # Under the mock environment we get a 500 error when trying to reach the tokenizer.
        with mock.patch('requests.Session.request'    ,			return_value=__UpperCamelCase       ) as mock_head:
          lowerCAmelCase_   :				Any								= BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'       )
          # This check we did call the fake head request
          mock_head.assert_called()



      @require_tokenizers
      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[Any]       ):
        # A mock response for an HTTP head request to emulate server down
        lowerCAmelCase_   :				List[str]								= mock.Mock()
        lowerCAmelCase_   :				Dict								= 5_0_0
        lowerCAmelCase_   :				List[str]								= {}
        lowerCAmelCase_   :				List[Any]								= HTTPError
        lowerCAmelCase_   :				Optional[Any]								= {}

        # Download this model to make sure it's in the cache.
        lowerCAmelCase_   :				int								= GPTaTokenizerFast.from_pretrained('gpt2'       )

        # Under the mock environment we get a 500 error when trying to reach the tokenizer.
        with mock.patch('requests.Session.request'    ,			return_value=__UpperCamelCase       ) as mock_head:
          lowerCAmelCase_   :				List[str]								= GPTaTokenizerFast.from_pretrained('gpt2'       )
          # This check we did call the fake head request
          mock_head.assert_called()



      def      SCREAMING_SNAKE_CASE__ (      self				:      Tuple       ):
        # This test is for deprecated behavior and can be removed in v5
        try:
          lowerCAmelCase_   :				str								= tempfile.mktemp()
          with open(__UpperCamelCase    ,			'wb'       ) as f:
            http_get('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'    ,			__UpperCamelCase       )

          lowerCAmelCase_   :				Tuple								= AlbertTokenizer.from_pretrained(__UpperCamelCase       )
        finally:
          os.remove(__UpperCamelCase       )

        # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
        # the current folder and have the right name.
        if os.path.isfile('tokenizer.json'       ):
          # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
          return
        try:
          with open('tokenizer.json'    ,			'wb'       ) as f:
            http_get('https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json'    ,			__UpperCamelCase       )
          lowerCAmelCase_   :				Tuple								= AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'       )
          # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
          self.assertEqual(tokenizer.vocab_size    ,			1_0_0_0       )
          # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

        finally:
          os.remove('tokenizer.json'       )





      def      SCREAMING_SNAKE_CASE__ (      self				:      Union[str, Any]       ):
        # This test is for deprecated behavior and can be removed in v5
        lowerCAmelCase_   :				Optional[Any]								= AlbertTokenizer.from_pretrained('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'       )







@is_staging_test
class       UpperCamelCase__   (	unittest.TestCase  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple       ):
        lowerCAmelCase_   :				int								= TOKEN
        HfFolder.save_token(__UpperCamelCase       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Any       ):
        try:
          delete_repo(token=cls._token    ,			repo_id='test-tokenizer'       )
        except HTTPError:
          pass

        try:
          delete_repo(token=cls._token    ,			repo_id='valid_org/test-tokenizer-org'       )
        except HTTPError:
          pass

        try:
          delete_repo(token=cls._token    ,			repo_id='test-dynamic-tokenizer'       )
        except HTTPError:
          pass



      def      SCREAMING_SNAKE_CASE__ (      self				:      int       ):
        with tempfile.TemporaryDirectory() as tmp_dir:
          lowerCAmelCase_   :				Any								= os.path.join(__UpperCamelCase    ,			'vocab.txt'       )
          with open(__UpperCamelCase    ,			'w'    ,			encoding='utf-8'       ) as vocab_writer:
            vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )
          lowerCAmelCase_   :				Union[str, Any]								= BertTokenizer(__UpperCamelCase       )

        tokenizer.push_to_hub('test-tokenizer'    ,			use_auth_token=self._token       )
        lowerCAmelCase_   :				Dict								= BertTokenizer.from_pretrained(F"{USER}/test-tokenizer"       )
        self.assertDictEqual(new_tokenizer.vocab    ,			tokenizer.vocab       )

        # Reset repo
        delete_repo(token=self._token    ,			repo_id='test-tokenizer'       )

        # Push to hub via save_pretrained
        with tempfile.TemporaryDirectory() as tmp_dir:
          tokenizer.save_pretrained(__UpperCamelCase    ,			repo_id='test-tokenizer'    ,			push_to_hub=__UpperCamelCase    ,			use_auth_token=self._token       )

        lowerCAmelCase_   :				Dict								= BertTokenizer.from_pretrained(F"{USER}/test-tokenizer"       )
        self.assertDictEqual(new_tokenizer.vocab    ,			tokenizer.vocab       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[int]       ):
        with tempfile.TemporaryDirectory() as tmp_dir:
          lowerCAmelCase_   :				List[Any]								= os.path.join(__UpperCamelCase    ,			'vocab.txt'       )
          with open(__UpperCamelCase    ,			'w'    ,			encoding='utf-8'       ) as vocab_writer:
            vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )
          lowerCAmelCase_   :				Dict								= BertTokenizer(__UpperCamelCase       )

        tokenizer.push_to_hub('valid_org/test-tokenizer-org'    ,			use_auth_token=self._token       )
        lowerCAmelCase_   :				Any								= BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'       )
        self.assertDictEqual(new_tokenizer.vocab    ,			tokenizer.vocab       )

        # Reset repo
        delete_repo(token=self._token    ,			repo_id='valid_org/test-tokenizer-org'       )

        # Push to hub via save_pretrained
        with tempfile.TemporaryDirectory() as tmp_dir:
          tokenizer.save_pretrained(
              __UpperCamelCase    ,			repo_id='valid_org/test-tokenizer-org'    ,			push_to_hub=__UpperCamelCase    ,			use_auth_token=self._token       )

        lowerCAmelCase_   :				int								= BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'       )
        self.assertDictEqual(new_tokenizer.vocab    ,			tokenizer.vocab       )





      @require_tokenizers
      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        CustomTokenizer.register_for_auto_class()
        with tempfile.TemporaryDirectory() as tmp_dir:
          lowerCAmelCase_   :				Union[str, Any]								= os.path.join(__UpperCamelCase    ,			'vocab.txt'       )
          with open(__UpperCamelCase    ,			'w'    ,			encoding='utf-8'       ) as vocab_writer:
            vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )
          lowerCAmelCase_   :				Union[str, Any]								= CustomTokenizer(__UpperCamelCase       )

        # No fast custom tokenizer
        tokenizer.push_to_hub('test-dynamic-tokenizer'    ,			use_auth_token=self._token       )

        lowerCAmelCase_   :				str								= AutoTokenizer.from_pretrained(F"{USER}/test-dynamic-tokenizer"    ,			trust_remote_code=__UpperCamelCase       )
        # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
        self.assertEqual(tokenizer.__class__.__name__    ,			'CustomTokenizer'       )

        # Fast and slow custom tokenizer
        CustomTokenizerFast.register_for_auto_class()
        with tempfile.TemporaryDirectory() as tmp_dir:
          lowerCAmelCase_   :				List[str]								= os.path.join(__UpperCamelCase    ,			'vocab.txt'       )
          with open(__UpperCamelCase    ,			'w'    ,			encoding='utf-8'       ) as vocab_writer:
            vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )

          lowerCAmelCase_   :				Optional[int]								= BertTokenizerFast.from_pretrained(__UpperCamelCase       )
          bert_tokenizer.save_pretrained(__UpperCamelCase       )
          lowerCAmelCase_   :				int								= CustomTokenizerFast.from_pretrained(__UpperCamelCase       )

        tokenizer.push_to_hub('test-dynamic-tokenizer'    ,			use_auth_token=self._token       )

        lowerCAmelCase_   :				List[Any]								= AutoTokenizer.from_pretrained(F"{USER}/test-dynamic-tokenizer"    ,			trust_remote_code=__UpperCamelCase       )
        # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
        self.assertEqual(tokenizer.__class__.__name__    ,			'CustomTokenizerFast'       )
        lowerCAmelCase_   :				Tuple								= AutoTokenizer.from_pretrained(
            F"{USER}/test-dynamic-tokenizer"    ,			use_fast=__UpperCamelCase    ,			trust_remote_code=__UpperCamelCase       )
        # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
        self.assertEqual(tokenizer.__class__.__name__    ,			'CustomTokenizer'       )







class       UpperCamelCase__   (	unittest.TestCase  ):




      """simple docstring"""




      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        lowerCAmelCase_   :				Optional[int]								= Trie()
        trie.add('Hello 友達'       )
        self.assertEqual(trie.data    ,			{'H': {'e': {'l': {'l': {'o': {' ': {'友': {'達': {'': 1}}}}}}}}}       )
        trie.add('Hello'       )
        trie.data
        self.assertEqual(trie.data    ,			{'H': {'e': {'l': {'l': {'o': {'': 1, ' ': {'友': {'達': {'': 1}}}}}}}}}       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Dict       ):
        lowerCAmelCase_   :				str								= Trie()
        self.assertEqual(trie.split('[CLS] This is a extra_id_100'       )    ,			['[CLS] This is a extra_id_100']       )
        trie.add('[CLS]'       )
        trie.add('extra_id_1'       )
        trie.add('extra_id_100'       )
        self.assertEqual(trie.split('[CLS] This is a extra_id_100'       )    ,			['[CLS]', ' This is a ', 'extra_id_100']       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        lowerCAmelCase_   :				Dict								= Trie()
        trie.add('A'       )
        self.assertEqual(trie.split('ABC'       )    ,			['A', 'BC']       )
        self.assertEqual(trie.split('BCA'       )    ,			['BC', 'A']       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Any       ):
        lowerCAmelCase_   :				Optional[Any]								= Trie()
        trie.add('TOKEN]'       )
        trie.add('[SPECIAL_TOKEN]'       )
        self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'       )    ,			['This is something ', '[SPECIAL_TOKEN]']       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      List[str]       ):
        lowerCAmelCase_   :				Optional[Any]								= Trie()
        trie.add('A'       )
        trie.add('P'       )
        trie.add('[SPECIAL_TOKEN]'       )
        self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'       )    ,			['This is something ', '[SPECIAL_TOKEN]']       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Tuple       ):
        lowerCAmelCase_   :				List[str]								= Trie()
        trie.add('AB'       )
        trie.add('B'       )
        trie.add('C'       )
        self.assertEqual(trie.split('ABC'       )    ,			['AB', 'C']       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        lowerCAmelCase_   :				int								= Trie()
        trie.add('ABC'       )
        trie.add('B'       )
        trie.add('CD'       )
        self.assertEqual(trie.split('ABCD'       )    ,			['ABC', 'D']       )





      def      SCREAMING_SNAKE_CASE__ (      self				:      Dict       ):
        # Even if the offsets are wrong, we necessarily output correct string
        # parts.
        lowerCAmelCase_   :				Optional[int]								= Trie()
        lowerCAmelCase_   :				Any								= trie.cut_text('ABC'    ,			[0, 0, 2, 1, 2, 3]       )
        self.assertEqual(__UpperCamelCase    ,			['AB', 'C']       )












"""simple docstring"""
import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
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   (	lowercase_     ,							unittest.TestCase ):
					UpperCamelCase      =							'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''


					def 	lowerCamelCase       (					self			:Optional[int]     ,       __UpperCamelCase			:Union[str, Any]=0		):
												A		=  floats_tensor((1, 3, 1_28, 1_28)     ,       rng=random.Random(__UpperCamelCase		)		)
												A		=  np.random.RandomState(__UpperCamelCase		)
												A		=  {
												    "prompt": "A painting of a squirrel eating a burger",
												    "image": image,
												    "generator": generator,
												    "num_inference_steps": 3,
												    "strength": 0.75,
												    "guidance_scale": 7.5,
												    "output_type": "numpy",
												}
												return inputs


					def 	lowerCamelCase       (					self			:Any		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1].flatten()

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.69_643, 0.58_484, 0.50_314, 0.58_760, 0.55_368, 0.59_643, 0.51_529, 0.41_217, 0.49_087]		)
												assert np.abs(image_slice - expected_slice		).max() < 1e-1


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  PNDMScheduler.from_config(pipe.scheduler.config     ,       skip_prk_steps=__UpperCamelCase		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.61_737, 0.54_642, 0.53_183, 0.54_465, 0.52_742, 0.60_525, 0.49_969, 0.40_655, 0.48_154]		)

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


					def 	lowerCamelCase       (					self			:Optional[Any]		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												# warmup pass to apply optimizations
												A		=  pipe(**self.get_dummy_inputs()		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.52_761, 0.59_977, 0.49_033, 0.49_619, 0.54_282, 0.50_311, 0.47_600, 0.40_918, 0.45_203]		)

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


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  EulerDiscreteScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]		)

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


					def 	lowerCamelCase       (					self			:Optional[Any]		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]		)

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


					def 	lowerCamelCase       (					self			:Union[str, Any]		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.65_331, 0.58_277, 0.48_204, 0.56_059, 0.53_665, 0.56_235, 0.50_969, 0.40_009, 0.46_552]		)

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







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


					@property
					def 	lowerCamelCase       (					self			:Optional[Any]		):
												return (
												    "CUDAExecutionProvider",
												    {
												        "gpu_mem_limit": "15000000000",  # 15GB
												        "arena_extend_strategy": "kSameAsRequested",
												    },
												)


					@property
					def 	lowerCamelCase       (					self			:Optional[int]		):
												A		=  ort.SessionOptions()
												A		=  False
												return options


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  load_image(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
												    "/img2img/sketch-mountains-input.jpg"		)
												A		=  init_image.resize((7_68, 5_12)		)
												# using the PNDM scheduler by default
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(
												    "CompVis/stable-diffusion-v1-4"     ,       revision="onnx"     ,       safety_checker=__UpperCamelCase     ,       feature_extractor=__UpperCamelCase     ,       provider=self.gpu_provider     ,       sess_options=self.gpu_options     ,       )
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  "A fantasy landscape, trending on artstation"

												A		=  np.random.RandomState(0		)
												A		=  pipe(
												    prompt=__UpperCamelCase     ,       image=__UpperCamelCase     ,       strength=0.75     ,       guidance_scale=7.5     ,       num_inference_steps=10     ,       generator=__UpperCamelCase     ,       output_type="np"     ,       )
												A		=  output.images
												A		=  images[0, 2_55:2_58, 3_83:3_86, -1]

												assert images.shape == (1, 5_12, 7_68, 3)
												A		=  np.array([0.4_909, 0.5_059, 0.5_372, 0.4_623, 0.4_876, 0.5_049, 0.4_820, 0.4_956, 0.5_019]		)
												# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

												assert np.abs(image_slice.flatten() - expected_slice		).max() < 2e-2


					def 	lowerCamelCase       (					self			:Any		):
												A		=  load_image(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
												    "/img2img/sketch-mountains-input.jpg"		)
												A		=  init_image.resize((7_68, 5_12)		)
												A		=  LMSDiscreteScheduler.from_pretrained(
												    "runwayml/stable-diffusion-v1-5"     ,       subfolder="scheduler"     ,       revision="onnx"		)
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(
												    "runwayml/stable-diffusion-v1-5"     ,       revision="onnx"     ,       scheduler=__UpperCamelCase     ,       safety_checker=__UpperCamelCase     ,       feature_extractor=__UpperCamelCase     ,       provider=self.gpu_provider     ,       sess_options=self.gpu_options     ,       )
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  "A fantasy landscape, trending on artstation"

												A		=  np.random.RandomState(0		)
												A		=  pipe(
												    prompt=__UpperCamelCase     ,       image=__UpperCamelCase     ,       strength=0.75     ,       guidance_scale=7.5     ,       num_inference_steps=20     ,       generator=__UpperCamelCase     ,       output_type="np"     ,       )
												A		=  output.images
												A		=  images[0, 2_55:2_58, 3_83:3_86, -1]

												assert images.shape == (1, 5_12, 7_68, 3)
												A		=  np.array([0.8_043, 0.926, 0.9_581, 0.8_119, 0.8_954, 0.913, 0.7_209, 0.7_463, 0.7_431]		)
												# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

												assert np.abs(image_slice.flatten() - expected_slice		).max() < 2e-2


